Swig v3.0.12

Change-Id: Id2d403ccfad34ad29f9550049b028684902fea10
source: ab/4081059

970 files changed, 74651 insertions, 55372 deletions

diff --git a/bin/ccache-swig b/bin/ccache-swig
deleted file mode 100755
index 6ada796..0000000
--- a/bin/ccache-swig
+++ /dev/null
diff --git a/bin/swig b/bin/swig
index d643699..eba0838 100755
--- a/bin/swig
+++ b/bin/swig
diff --git a/build-common.sh b/build-common.sh
deleted file mode 100644
index d6d3a32..0000000
--- a/build-common.sh
+++ /dev/null
@@ -1,113 +0,0 @@
-# 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"
-        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}_${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 .
-    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
deleted file mode 100755
index a54aa93..0000000
--- a/build-swig.sh
+++ /dev/null
@@ -1,29 +0,0 @@
-#!/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
-
-$RD/$PROJ-$VER/configure --prefix=$INSTALL
-make -j$CORES
-make install
-cd $INSTALL/bin
-ln -s swig swig2.0
-
-commit_and_push
diff --git a/revisions b/revisions
new file mode 100644
index 0000000..dc53131
--- /dev/null
+++ b/revisions
@@ -0,0 +1,5 @@
+external/lldb-utils 6d596eeb80688412346080adb28552790331a112
+external/swig fbeb566014a1d320df972aef965daf042db7db36
+prebuilts/gcc/linux-x86/host/x86_64-linux-glibc2.15-4.8 73ca99196723f810dad42390d154654354f57c16
+prebuilts/clang/linux-x86/host/3.6 c4da85d149dd9f763fb9d1db8d165621216a2aea
+external/pcre c0b835ad863cbed40715e439043aa5ef1114c8ad
diff --git a/share/man/man1/ccache-swig.1 b/share/man/man1/ccache-swig.1
deleted file mode 100644
index 0081b6d..0000000
--- a/share/man/man1/ccache-swig.1
+++ /dev/null
@@ -1,453 +0,0 @@
-.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
deleted file mode 100644
index f08f87c..0000000
--- a/share/swig/2.0.11/allegrocl/allegrocl.swg
+++ /dev/null
@@ -1,612 +0,0 @@
-/* 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/allkw.swg b/share/swig/2.0.11/allkw.swg
deleted file mode 100644
index 2e0dad6..0000000
--- a/share/swig/2.0.11/allkw.swg
+++ /dev/null
@@ -1,32 +0,0 @@
-#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/carrays.i b/share/swig/2.0.11/carrays.i
deleted file mode 100644
index f125105..0000000
--- a/share/swig/2.0.11/carrays.i
+++ /dev/null
@@ -1,116 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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
deleted file mode 100644
index 22a6d9d..0000000
--- a/share/swig/2.0.11/cdata.i
+++ /dev/null
@@ -1,81 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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
deleted file mode 100644
index 427a8dc..0000000
--- a/share/swig/2.0.11/cffi/cffi.swg
+++ /dev/null
@@ -1,291 +0,0 @@
-/* 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
deleted file mode 100644
index 525c1a6..0000000
--- a/share/swig/2.0.11/chicken/chicken.swg
+++ /dev/null
@@ -1,781 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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/chickenrun.swg b/share/swig/2.0.11/chicken/chickenrun.swg
deleted file mode 100644
index 07db419..0000000
--- a/share/swig/2.0.11/chicken/chickenrun.swg
+++ /dev/null
@@ -1,374 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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/csharp/arrays_csharp.i b/share/swig/2.0.11/csharp/arrays_csharp.i
deleted file mode 100644
index 513330e..0000000
--- a/share/swig/2.0.11/csharp/arrays_csharp.i
+++ /dev/null
@@ -1,137 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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
deleted file mode 100644
index 09a1647..0000000
--- a/share/swig/2.0.11/csharp/boost_intrusive_ptr.i
+++ /dev/null
@@ -1,511 +0,0 @@
-// 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
deleted file mode 100644
index 5e6f664..0000000
--- a/share/swig/2.0.11/csharp/boost_shared_ptr.i
+++ /dev/null
@@ -1,238 +0,0 @@
-// 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
deleted file mode 100644
index c0b896e..0000000
--- a/share/swig/2.0.11/csharp/csharp.swg
+++ /dev/null
@@ -1,1017 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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
deleted file mode 100644
index a1c56a4..0000000
--- a/share/swig/2.0.11/csharp/csharphead.swg
+++ /dev/null
@@ -1,334 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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
deleted file mode 100644
index 9a6d979..0000000
--- a/share/swig/2.0.11/csharp/csharpkw.swg
+++ /dev/null
@@ -1,94 +0,0 @@
-#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
deleted file mode 100644
index 7768d8c..0000000
--- a/share/swig/2.0.11/csharp/director.swg
+++ /dev/null
@@ -1,47 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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
deleted file mode 100644
index 70e483f..0000000
--- a/share/swig/2.0.11/csharp/enums.swg
+++ /dev/null
@@ -1,86 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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
deleted file mode 100644
index a193e75..0000000
--- a/share/swig/2.0.11/csharp/enumsimple.swg
+++ /dev/null
@@ -1,88 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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
deleted file mode 100644
index ed483f0..0000000
--- a/share/swig/2.0.11/csharp/enumtypesafe.swg
+++ /dev/null
@@ -1,130 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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_except.i b/share/swig/2.0.11/csharp/std_except.i
deleted file mode 100644
index 27eb84b..0000000
--- a/share/swig/2.0.11/csharp/std_except.i
+++ /dev/null
@@ -1,30 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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
deleted file mode 100644
index acd1906..0000000
--- a/share/swig/2.0.11/csharp/std_map.i
+++ /dev/null
@@ -1,312 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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_vector.i b/share/swig/2.0.11/csharp/std_vector.i
deleted file mode 100644
index 5a21ad3..0000000
--- a/share/swig/2.0.11/csharp/std_vector.i
+++ /dev/null
@@ -1,421 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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
deleted file mode 100644
index 9142d36..0000000
--- a/share/swig/2.0.11/csharp/std_wstring.i
+++ /dev/null
@@ -1,114 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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/typemaps.i b/share/swig/2.0.11/csharp/typemaps.i
deleted file mode 100644
index 79f5596..0000000
--- a/share/swig/2.0.11/csharp/typemaps.i
+++ /dev/null
@@ -1,253 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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
deleted file mode 100644
index 1d95edd..0000000
--- a/share/swig/2.0.11/csharp/wchar.i
+++ /dev/null
@@ -1,102 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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/d/boost_shared_ptr.i b/share/swig/2.0.11/d/boost_shared_ptr.i
deleted file mode 100644
index bfa2aa6..0000000
--- a/share/swig/2.0.11/d/boost_shared_ptr.i
+++ /dev/null
@@ -1,201 +0,0 @@
-%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
deleted file mode 100644
index 37b59c8..0000000
--- a/share/swig/2.0.11/d/carrays.i
+++ /dev/null
@@ -1,111 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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/dclassgen.swg b/share/swig/2.0.11/d/dclassgen.swg
deleted file mode 100644
index ceaf507..0000000
--- a/share/swig/2.0.11/d/dclassgen.swg
+++ /dev/null
@@ -1,142 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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
deleted file mode 100644
index 6972a0c..0000000
--- a/share/swig/2.0.11/d/ddirectives.swg
+++ /dev/null
@@ -1,10 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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
deleted file mode 100644
index 5917da9..0000000
--- a/share/swig/2.0.11/d/denums.swg
+++ /dev/null
@@ -1,60 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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/dhead.swg b/share/swig/2.0.11/d/dhead.swg
deleted file mode 100644
index 7a2f4fd..0000000
--- a/share/swig/2.0.11/d/dhead.swg
+++ /dev/null
@@ -1,344 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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
deleted file mode 100644
index 9692e03..0000000
--- a/share/swig/2.0.11/d/director.swg
+++ /dev/null
@@ -1,46 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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/dmemberfunctionpointers.swg b/share/swig/2.0.11/d/dmemberfunctionpointers.swg
deleted file mode 100644
index c33ff38..0000000
--- a/share/swig/2.0.11/d/dmemberfunctionpointers.swg
+++ /dev/null
@@ -1,92 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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/dswigtype.swg b/share/swig/2.0.11/d/dswigtype.swg
deleted file mode 100644
index 41336dc..0000000
--- a/share/swig/2.0.11/d/dswigtype.swg
+++ /dev/null
@@ -1,184 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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/std_except.i b/share/swig/2.0.11/d/std_except.i
deleted file mode 100644
index 2b557e5..0000000
--- a/share/swig/2.0.11/d/std_except.i
+++ /dev/null
@@ -1,30 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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_vector.i b/share/swig/2.0.11/d/std_vector.i
deleted file mode 100644
index b7d4e22..0000000
--- a/share/swig/2.0.11/d/std_vector.i
+++ /dev/null
@@ -1,591 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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/exception.i b/share/swig/2.0.11/exception.i
deleted file mode 100644
index 050042d..0000000
--- a/share/swig/2.0.11/exception.i
+++ /dev/null
@@ -1,304 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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
deleted file mode 100644
index b12148e..0000000
--- a/share/swig/2.0.11/gcj/cni.i
+++ /dev/null
@@ -1,43 +0,0 @@
-%{
-#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/go/cdata.i b/share/swig/2.0.11/go/cdata.i
deleted file mode 100644
index 0dac642..0000000
--- a/share/swig/2.0.11/go/cdata.i
+++ /dev/null
@@ -1,64 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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/go.swg b/share/swig/2.0.11/go/go.swg
deleted file mode 100644
index cc3beef..0000000
--- a/share/swig/2.0.11/go/go.swg
+++ /dev/null
@@ -1,541 +0,0 @@
-/* ------------------------------------------------------------
- * 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/goruntime.swg b/share/swig/2.0.11/go/goruntime.swg
deleted file mode 100644
index 4b7daf4..0000000
--- a/share/swig/2.0.11/go/goruntime.swg
+++ /dev/null
@@ -1,218 +0,0 @@
-/* ------------------------------------------------------------
- * 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_except.i b/share/swig/2.0.11/go/std_except.i
deleted file mode 100644
index 789a335..0000000
--- a/share/swig/2.0.11/go/std_except.i
+++ /dev/null
@@ -1,29 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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_string.i b/share/swig/2.0.11/go/std_string.i
deleted file mode 100644
index 9922fbe..0000000
--- a/share/swig/2.0.11/go/std_string.i
+++ /dev/null
@@ -1,55 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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
deleted file mode 100644
index f4ce843..0000000
--- a/share/swig/2.0.11/go/std_vector.i
+++ /dev/null
@@ -1,78 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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/typemaps.i b/share/swig/2.0.11/go/typemaps.i
deleted file mode 100644
index c339fb3..0000000
--- a/share/swig/2.0.11/go/typemaps.i
+++ /dev/null
@@ -1,292 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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_TYPEMAP(long, int64);
-INOUT_TYPEMAP(unsigned long, uint64);
-INOUT_TYPEMAP(long long, int64);
-INOUT_TYPEMAP(unsigned long long, uint64);
-INOUT_TYPEMAP(float, float32);
-INOUT_TYPEMAP(double, float64);
-
-#undef INOUT_TYPEMAP
diff --git a/share/swig/2.0.11/guile/guile_scm_run.swg b/share/swig/2.0.11/guile/guile_scm_run.swg
deleted file mode 100644
index 0ac51f9..0000000
--- a/share/swig/2.0.11/guile/guile_scm_run.swg
+++ /dev/null
@@ -1,504 +0,0 @@
-/* -----------------------------------------------------------------------------
- * guile_scm_run.swg
- * ----------------------------------------------------------------------------- */
-
-#include <libguile.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <assert.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/* In the code below, use guile 2.0 compatible functions where possible.
-   Functions that don't exist in older versions will be mapped to
-   a deprecated equivalent for those versions only */
-#if defined (SCM_MAJOR_VERSION) && (SCM_MAJOR_VERSION < 2)
-
-static SCM
-scm_module_variable (SCM module, SCM sym)
-{
-  return scm_sym2var (sym, scm_module_lookup_closure (module), SCM_BOOL_F);
-}
-
-#endif
-
-#if SCM_MAJOR_VERSION >= 2
-// scm_c_define_gsubr takes a different parameter type
-// depending on the guile version
-
-typedef scm_t_subr swig_guile_proc;
-#else
-typedef SCM (*swig_guile_proc)();
-#endif
-typedef SCM (*guile_destructor)(SCM);
-
-typedef struct swig_guile_clientdata {
-  guile_destructor destroy;
-  SCM goops_class;
-} swig_guile_clientdata;
-
-#define SWIG_scm2str(s) \
-  SWIG_Guile_scm2newstr(s, NULL)
-#define SWIG_str02scm(str) \
-  str ? scm_from_locale_string(str) : SCM_BOOL_F 
-# define SWIG_malloc(size) \
-  scm_malloc(size)
-# define SWIG_free(mem) \
-  free(mem)
-#define SWIG_ConvertPtr(s, result, type, flags) \
-  SWIG_Guile_ConvertPtr(s, result, type, flags)
-#define SWIG_MustGetPtr(s, type, argnum, flags) \
-  SWIG_Guile_MustGetPtr(s, type, argnum, flags, FUNC_NAME)
-#define SWIG_NewPointerObj(ptr, type, owner) \
-  SWIG_Guile_NewPointerObj((void*)ptr, type, owner)
-#define SWIG_PointerAddress(object) \
-  SWIG_Guile_PointerAddress(object)
-#define SWIG_PointerType(object) \
-  SWIG_Guile_PointerType(object)
-#define SWIG_IsPointerOfType(object, type) \
-  SWIG_Guile_IsPointerOfType(object, type)
-#define SWIG_IsPointer(object) \
-  SWIG_Guile_IsPointer(object)
-#define SWIG_contract_assert(expr, msg)				\
-  if (!(expr))							\
-    scm_error(scm_from_locale_symbol("swig-contract-assertion-failed"),	\
-	      (char *) FUNC_NAME, (char *) msg,			\
-	      SCM_EOL, SCM_BOOL_F); else
-
-/* for C++ member pointers, ie, member methods */
-#define SWIG_ConvertMember(obj, ptr, sz, ty) \
-  SWIG_Guile_ConvertMember(obj, ptr, sz, ty, FUNC_NAME)
-#define SWIG_NewMemberObj(ptr, sz, type) \
-  SWIG_Guile_NewMemberObj(ptr, sz, type, FUNC_NAME)
-  
-/* Runtime API */
-static swig_module_info *SWIG_Guile_GetModule(void *SWIGUNUSEDPARM(clientdata));
-#define SWIG_GetModule(clientdata) SWIG_Guile_GetModule(clientdata)
-#define SWIG_SetModule(clientdata, pointer) SWIG_Guile_SetModule(pointer)
-  
-SWIGINTERN char *
-SWIG_Guile_scm2newstr(SCM str, size_t *len) {
-#define FUNC_NAME "SWIG_Guile_scm2newstr"
-  char *ret;
-  char *tmp;
-  size_t l;
-
-  SCM_ASSERT (scm_is_string(str), str, 1, FUNC_NAME);
-  l = scm_c_string_length(str);
-
-  ret = (char *) SWIG_malloc( (l + 1) * sizeof(char));
-  if (!ret) return NULL;
-
-  tmp = scm_to_locale_string(str);
-  memcpy(ret, tmp, l);
-  free(tmp);
-
-  ret[l] = '\0';
-  if (len) *len = l;
-  return ret;
-#undef FUNC_NAME
-}
-
-static int swig_initialized = 0;
-static scm_t_bits swig_tag = 0;
-static scm_t_bits swig_collectable_tag = 0;
-static scm_t_bits swig_destroyed_tag = 0;
-static scm_t_bits swig_member_function_tag = 0;
-static SCM swig_make_func = SCM_EOL;
-static SCM swig_keyword = SCM_EOL;
-static SCM swig_symbol = SCM_EOL;
-
-#define SWIG_Guile_GetSmob(x) \
-  ( !scm_is_null(x) && SCM_INSTANCEP(x) && scm_is_true(scm_slot_exists_p(x, swig_symbol)) \
-      ? scm_slot_ref(x, swig_symbol) : (x) )
-
-SWIGINTERN SCM
-SWIG_Guile_NewPointerObj(void *ptr, swig_type_info *type, int owner)
-{
-  if (ptr == NULL)
-    return SCM_EOL;
-  else {
-    SCM smob;
-    swig_guile_clientdata *cdata = (swig_guile_clientdata *) type->clientdata;
-    if (owner)
-      SCM_NEWSMOB2(smob, swig_collectable_tag, ptr, (void *) type);
-    else
-      SCM_NEWSMOB2(smob, swig_tag, ptr, (void *) type);
-
-    if (!cdata || SCM_NULLP(cdata->goops_class) || swig_make_func == SCM_EOL ) {
-      return smob;
-    } else {
-      /* the scm_make() C function only handles the creation of gf,
-	 methods and classes (no instances) the (make ...) function is
-	 later redefined in goops.scm.  So we need to call that
-	 Scheme function. */
-      return scm_apply(swig_make_func,
-		       scm_list_3(cdata->goops_class,
-				  swig_keyword,
-				  smob),
-		       SCM_EOL);
-    }
-  }
-}
-
-SWIGINTERN unsigned long
-SWIG_Guile_PointerAddress(SCM object)
-{
-  SCM smob = SWIG_Guile_GetSmob(object);
-  if (SCM_NULLP(smob)) return 0;
-  else if (SCM_SMOB_PREDICATE(swig_tag, smob)
-	   || SCM_SMOB_PREDICATE(swig_collectable_tag, smob)
-	   || SCM_SMOB_PREDICATE(swig_destroyed_tag, smob)) {
-    return (unsigned long) (void *) SCM_CELL_WORD_1(smob);
-  }
-  else scm_wrong_type_arg("SWIG-Guile-PointerAddress", 1, object);
-}
-
-SWIGINTERN swig_type_info *
-SWIG_Guile_PointerType(SCM object)
-{
-  SCM smob = SWIG_Guile_GetSmob(object);
-  if (SCM_NULLP(smob)) return NULL;
-  else if (SCM_SMOB_PREDICATE(swig_tag, smob)
-	   || SCM_SMOB_PREDICATE(swig_collectable_tag, smob)
-	   || SCM_SMOB_PREDICATE(swig_destroyed_tag, smob)) {
-    return (swig_type_info *) SCM_CELL_WORD_2(smob);
-  }
-  else scm_wrong_type_arg("SWIG-Guile-PointerType", 1, object);
-}
-  
-SWIGINTERN int
-SWIG_Guile_ConvertPtr(SCM s, void **result, swig_type_info *type, int flags)
-{
-  swig_cast_info *cast;
-  swig_type_info *from;
-  SCM smob = SWIG_Guile_GetSmob(s);
-
-  if (SCM_NULLP(smob)) {
-    *result = NULL;
-    return SWIG_OK;
-  } else if (SCM_SMOB_PREDICATE(swig_tag, smob) || SCM_SMOB_PREDICATE(swig_collectable_tag, smob)) {
-    /* we do not accept smobs representing destroyed pointers */
-    from = (swig_type_info *) SCM_CELL_WORD_2(smob);
-    if (!from) return SWIG_ERROR;
-    if (type) {
-      cast = SWIG_TypeCheckStruct(from, type);
-      if (cast) {
-        int newmemory = 0;
-        *result = SWIG_TypeCast(cast, (void *) SCM_CELL_WORD_1(smob), &newmemory);
-        assert(!newmemory); /* newmemory handling not yet implemented */
-        return SWIG_OK;
-      } else {
-        return SWIG_ERROR;
-      }
-    } else {
-      *result = (void *) SCM_CELL_WORD_1(smob);
-      return SWIG_OK;
-    }
-  }
-  return SWIG_ERROR;
-}
-
-SWIGINTERNINLINE void *
-SWIG_Guile_MustGetPtr (SCM s, swig_type_info *type,
-		       int argnum, int flags, const char *func_name)
-{
-  void *result;
-  int res = SWIG_Guile_ConvertPtr(s, &result, type, flags);
-  if (!SWIG_IsOK(res)) {
-    /* type mismatch */
-    scm_wrong_type_arg((char *) func_name, argnum, s);
-  }
-  return result;
-}
-
-SWIGINTERNINLINE int
-SWIG_Guile_IsPointerOfType (SCM s, swig_type_info *type)
-{
-  void *result;
-  if (SWIG_Guile_ConvertPtr(s, &result, type, 0)) {
-    /* type mismatch */
-    return 0;
-  }
-  else return 1;
-}
-
-SWIGINTERNINLINE int
-SWIG_Guile_IsPointer (SCM s)
-{
-  /* module might not be initialized yet, so initialize it */
-  SWIG_GetModule(0);
-  return SWIG_Guile_IsPointerOfType (s, NULL);
-}
-
-/* Mark a pointer object non-collectable */
-SWIGINTERN void
-SWIG_Guile_MarkPointerNoncollectable(SCM s)
-{
-  SCM smob = SWIG_Guile_GetSmob(s);
-  if (!SCM_NULLP(smob)) {
-    if (SCM_SMOB_PREDICATE(swig_tag, smob) || SCM_SMOB_PREDICATE(swig_collectable_tag, smob)) {
-      SCM_SET_CELL_TYPE(smob, swig_tag);
-    }
-    else scm_wrong_type_arg(NULL, 0, s);
-  }
-}
-
-/* Mark a pointer object destroyed */
-SWIGINTERN void
-SWIG_Guile_MarkPointerDestroyed(SCM s)
-{
-  SCM smob = SWIG_Guile_GetSmob(s);
-  if (!SCM_NULLP(smob)) {
-    if (SCM_SMOB_PREDICATE(swig_tag, smob) || SCM_SMOB_PREDICATE(swig_collectable_tag, smob)) {
-      SCM_SET_CELL_TYPE(smob, swig_destroyed_tag);
-    }
-    else scm_wrong_type_arg(NULL, 0, s);
-  }
-}
-
-/* Member functions */
-
-SWIGINTERN SCM
-SWIG_Guile_NewMemberObj(void *ptr, size_t sz, swig_type_info *type,
-			const char *func_name)
-{
-  SCM smob;
-  void *copy = malloc(sz);
-  memcpy(copy, ptr, sz);
-  SCM_NEWSMOB2(smob, swig_member_function_tag, copy, (void *) type);
-  return smob;
-}
-
-SWIGINTERN int
-SWIG_Guile_ConvertMember(SCM smob, void *ptr, size_t sz, swig_type_info *type,
-			 const char *func_name)
-{
-  swig_cast_info *cast;
-  swig_type_info *from;
-
-  if (SCM_SMOB_PREDICATE(swig_member_function_tag, smob)) {
-    from = (swig_type_info *) SCM_CELL_WORD_2(smob);
-    if (!from) return SWIG_ERROR;
-    if (type) {
-      cast = SWIG_TypeCheckStruct(from, type);
-      if (!cast) return SWIG_ERROR;
-    }
-    memcpy(ptr, (void *) SCM_CELL_WORD_1(smob), sz);
-    return SWIG_OK;
-  }
-  return SWIG_ERROR;
-}
-     
-
-/* Init */
-
-SWIGINTERN int
-print_swig_aux (SCM swig_smob, SCM port, scm_print_state *pstate, 
-                const char *attribute)
-{
-  swig_type_info *type;
-  
-  type = (swig_type_info *) SCM_CELL_WORD_2(swig_smob);
-  if (type) {
-    scm_puts((char *) "#<", port);
-    scm_puts((char *) attribute, port);
-    scm_puts((char *) "swig-pointer ", port);
-    scm_puts((char *) SWIG_TypePrettyName(type), port);
-    scm_puts((char *) " ", port);
-    scm_intprint((long) SCM_CELL_WORD_1(swig_smob), 16, port);
-    scm_puts((char *) ">", port);
-    /* non-zero means success */
-    return 1;
-  } else {
-    return 0;
-  }
-}
-
-  
-SWIGINTERN int
-print_swig (SCM swig_smob, SCM port, scm_print_state *pstate)
-{
-  return print_swig_aux(swig_smob, port, pstate, "");
-}
-
-SWIGINTERN int
-print_collectable_swig (SCM swig_smob, SCM port, scm_print_state *pstate)
-{
-  return print_swig_aux(swig_smob, port, pstate, "collectable-");
-}
-
-SWIGINTERN int
-print_destroyed_swig (SCM swig_smob, SCM port, scm_print_state *pstate)
-{
-  return print_swig_aux(swig_smob, port, pstate, "destroyed-");
-}
-
-SWIGINTERN int
-print_member_function_swig (SCM swig_smob, SCM port, scm_print_state *pstate)
-{
-  swig_type_info *type;
-  type = (swig_type_info *) SCM_CELL_WORD_2(swig_smob);
-  if (type) {
-    scm_puts((char *) "#<", port);
-    scm_puts((char *) "swig-member-function-pointer ", port);
-    scm_puts((char *) SWIG_TypePrettyName(type), port);
-    scm_puts((char *) " >", port);
-    /* non-zero means success */
-    return 1;
-  } else {
-    return 0;
-  }
-}
-
-SWIGINTERN SCM
-equalp_swig (SCM A, SCM B)
-{
-  if (SCM_CELL_WORD_0(A) == SCM_CELL_WORD_0(B) && SCM_CELL_WORD_1(A) == SCM_CELL_WORD_1(B) 
-      && SCM_CELL_WORD_2(A) == SCM_CELL_WORD_2(B))
-    return SCM_BOOL_T;
-  else return SCM_BOOL_F;
-}
-
-SWIGINTERN size_t
-free_swig(SCM A)
-{
-  swig_type_info *type = (swig_type_info *) SCM_CELL_WORD_2(A);
-  if (type) {
-    if (type->clientdata && ((swig_guile_clientdata *)type->clientdata)->destroy)
-      ((swig_guile_clientdata *)type->clientdata)->destroy(A);
-  } 
-  return 0;
-}
-
-SWIGINTERN size_t
-free_swig_member_function(SCM A)
-{
-  free((swig_type_info *) SCM_CELL_WORD_1(A));
-  return 0;
-}
-
-SWIGINTERN int
-ensure_smob_tag(SCM swig_module,
-		scm_t_bits *tag_variable,
-		const char *smob_name,
-		const char *scheme_variable_name)
-{
-  SCM variable = scm_module_variable(swig_module,
-                             scm_from_locale_symbol(scheme_variable_name));
-  if (scm_is_false(variable)) {
-    *tag_variable = scm_make_smob_type((char*)scheme_variable_name, 0);
-    scm_c_module_define(swig_module, scheme_variable_name, 
-                        scm_from_ulong(*tag_variable));
-    return 1;
-  }
-  else {
-    *tag_variable = scm_to_ulong(SCM_VARIABLE_REF(variable));
-    return 0;
-  }
-}
-
-SWIGINTERN SCM
-SWIG_Guile_Init ()
-{
-  static SCM swig_module;
-  
-  if (swig_initialized) return swig_module;
-  swig_initialized = 1;
-
-  swig_module = scm_c_resolve_module("Swig swigrun");
-  if (ensure_smob_tag(swig_module, &swig_tag,
-		      "swig-pointer", "swig-pointer-tag")) {
-    scm_set_smob_print(swig_tag, print_swig);
-    scm_set_smob_equalp(swig_tag, equalp_swig);
-  }
-  if (ensure_smob_tag(swig_module, &swig_collectable_tag,
-		      "collectable-swig-pointer", "collectable-swig-pointer-tag")) {
-    scm_set_smob_print(swig_collectable_tag, print_collectable_swig);
-    scm_set_smob_equalp(swig_collectable_tag, equalp_swig);
-    scm_set_smob_free(swig_collectable_tag, free_swig);
-  }
-  if (ensure_smob_tag(swig_module, &swig_destroyed_tag,
-		      "destroyed-swig-pointer", "destroyed-swig-pointer-tag")) {
-    scm_set_smob_print(swig_destroyed_tag, print_destroyed_swig);
-    scm_set_smob_equalp(swig_destroyed_tag, equalp_swig);
-  }
-  if (ensure_smob_tag(swig_module, &swig_member_function_tag,
-		      "swig-member-function-pointer", "swig-member-function-pointer-tag")) {
-    scm_set_smob_print(swig_member_function_tag, print_member_function_swig);
-    scm_set_smob_free(swig_member_function_tag, free_swig_member_function);
-  }
-  swig_make_func = scm_permanent_object(
-  scm_variable_ref(scm_c_module_lookup(scm_c_resolve_module("oop goops"), "make")));
-  swig_keyword = scm_permanent_object(scm_from_locale_keyword((char*) "init-smob"));
-  swig_symbol = scm_permanent_object(scm_from_locale_symbol("swig-smob"));
-#ifdef SWIG_INIT_RUNTIME_MODULE
-  SWIG_INIT_RUNTIME_MODULE
-#endif
-
-  return swig_module;
-}
-
-SWIGINTERN swig_module_info *
-SWIG_Guile_GetModule(void *SWIGUNUSEDPARM(clientdata))
-{
-  SCM module;
-  SCM variable;
-
-  module = SWIG_Guile_Init();
-
-  variable = scm_module_variable(module,
-                 scm_from_locale_symbol("swig-type-list-address" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME));
-  if (scm_is_false(variable)) {
-    return NULL;
-  } else {
-    return (swig_module_info *) scm_to_ulong(SCM_VARIABLE_REF(variable));
-  }
-}
-
-SWIGINTERN void
-SWIG_Guile_SetModule(swig_module_info *swig_module)
-{
-  SCM module;
-  SCM variable;
-
-  module = SWIG_Guile_Init();
-    
-  scm_module_define(module,
-                    scm_from_locale_symbol("swig-type-list-address" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME),
-                    scm_from_ulong((unsigned long) swig_module));
-}
-
-SWIGINTERN int
-SWIG_Guile_GetArgs (SCM *dest, SCM rest,
-		    int reqargs, int optargs,
-		    const char *procname)
-{
-  int i;
-  int num_args_passed = 0;
-  for (i = 0; i<reqargs; i++) {
-    if (!SCM_CONSP(rest))
-      scm_wrong_num_args(scm_from_locale_string(procname ? (char *) procname : "unknown procedure"));
-    *dest++ = SCM_CAR(rest);
-    rest = SCM_CDR(rest);
-    num_args_passed++;
-  }
-  for (i = 0; i<optargs && SCM_CONSP(rest); i++) {
-    *dest++ = SCM_CAR(rest);
-    rest = SCM_CDR(rest);
-    num_args_passed++;
-  }
-  for (; i<optargs; i++)
-    *dest++ = SCM_UNDEFINED;
-  if (!SCM_NULLP(rest))
-      scm_wrong_num_args(scm_from_locale_string(procname ? (char *) procname : "unknown procedure"));
-  return num_args_passed;
-}
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/share/swig/2.0.11/guile/std_common.i b/share/swig/2.0.11/guile/std_common.i
deleted file mode 100644
index 18c7db0..0000000
--- a/share/swig/2.0.11/guile/std_common.i
+++ /dev/null
@@ -1,24 +0,0 @@
-/* -----------------------------------------------------------------------------
- * std_common.i
- *
- * SWIG typemaps for STL - common utilities
- * ----------------------------------------------------------------------------- */
-
-%include <std/std_except.i>
-
-%apply size_t { std::size_t };
-
-#define SWIG_bool2scm(b) scm_from_bool(b ? 1 : 0)
-#define SWIG_string2scm(s) SWIG_str02scm(s.c_str())
-
-%{
-#include <string>
-
-inline std::string SWIG_scm2string(SCM x) {
-    char* temp;
-    temp = SWIG_scm2str(x);
-    std::string s(temp);
-    if (temp) SWIG_free(temp);
-    return s;
-}
-%}
diff --git a/share/swig/2.0.11/guile/std_except.i b/share/swig/2.0.11/guile/std_except.i
deleted file mode 100644
index 61bf481..0000000
--- a/share/swig/2.0.11/guile/std_except.i
+++ /dev/null
@@ -1,12 +0,0 @@
-// TODO: STL exception handling
-// Note that the generic std_except.i file did not work
-%{
-#include <stdexcept>
-%}
-
-namespace std {
-  %ignore exception;
-  struct exception {
-  };
-}
-
diff --git a/share/swig/2.0.11/guile/std_map.i b/share/swig/2.0.11/guile/std_map.i
deleted file mode 100644
index 1e1014f..0000000
--- a/share/swig/2.0.11/guile/std_map.i
+++ /dev/null
@@ -1,1352 +0,0 @@
-/* -----------------------------------------------------------------------------
- * std_map.i
- *
- * SWIG typemaps for std::map
- * ----------------------------------------------------------------------------- */
-
-%include <std_common.i>
-
-// ------------------------------------------------------------------------
-// std::map
-//
-// The aim of all that follows would be to integrate std::map with
-// Guile as much as possible, namely, to allow the user to pass and
-// be returned Scheme association lists.
-// const declarations are used to guess the intent of the function being
-// exported; therefore, the following rationale is applied:
-//
-//   -- f(std::map<T>), f(const std::map<T>&), f(const std::map<T>*):
-//      the parameter being read-only, either a Scheme alist or a
-//      previously wrapped std::map<T> can be passed.
-//   -- f(std::map<T>&), f(std::map<T>*):
-//      the parameter must be modified; therefore, only a wrapped std::map
-//      can be passed.
-//   -- std::map<T> f():
-//      the map is returned by copy; therefore, a Scheme alist
-//      is returned which is most easily used in other Scheme functions
-//   -- std::map<T>& f(), std::map<T>* f(), const std::map<T>& f(),
-//      const std::map<T>* f():
-//      the map is returned by reference; therefore, a wrapped std::map
-//      is returned
-// ------------------------------------------------------------------------
-
-%{
-#include <map>
-#include <algorithm>
-#include <stdexcept>
-%}
-
-// exported class
-
-namespace std {
-
-    template<class K, class T> class map {
-        %typemap(in) map<K,T> (std::map<K,T>* m) {
-            if (scm_is_null($input)) {
-                $1 = std::map<K,T >();
-            } else if (scm_is_pair($input)) {
-                $1 = std::map<K,T >();
-                SCM alist = $input;
-                while (!scm_is_null(alist)) {
-                    K* k;
-                    T* x;
-                    SCM entry, key, val;
-                    entry = SCM_CAR(alist);
-                    if (!scm_is_pair(entry))
-                        SWIG_exception(SWIG_TypeError,"alist expected");
-                    key = SCM_CAR(entry);
-                    val = SCM_CDR(entry);
-                    k = (K*) SWIG_MustGetPtr(key,$descriptor(K *),$argnum, 0);
-                    if (SWIG_ConvertPtr(val,(void**) &x,
-                                    $descriptor(T *), 0) != 0) {
-                        if (!scm_is_pair(val))
-                            SWIG_exception(SWIG_TypeError,"alist expected");
-                        val = SCM_CAR(val);
-                        x = (T*) SWIG_MustGetPtr(val,$descriptor(T *),$argnum, 0);
-                    }
-                    (($1_type &)$1)[*k] = *x;
-                    alist = SCM_CDR(alist);
-                }
-            } else {
-                $1 = *(($&1_type)
-                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
-            }
-        }
-        %typemap(in) const map<K,T>& (std::map<K,T> temp,
-                                      std::map<K,T>* m),
-                     const map<K,T>* (std::map<K,T> temp,
-                                      std::map<K,T>* m) {
-            if (scm_is_null($input)) {
-                temp = std::map<K,T >();
-                $1 = &temp;
-            } else if (scm_is_pair($input)) {
-                temp = std::map<K,T >();
-                $1 = &temp;
-                SCM alist = $input;
-                while (!scm_is_null(alist)) {
-                    K* k;
-                    T* x;
-                    SCM entry, key, val;
-                    entry = SCM_CAR(alist);
-                    if (!scm_is_pair(entry))
-                        SWIG_exception(SWIG_TypeError,"alist expected");
-                    key = SCM_CAR(entry);
-                    val = SCM_CDR(entry);
-                    k = (K*) SWIG_MustGetPtr(key,$descriptor(K *),$argnum, 0);
-                    if (SWIG_ConvertPtr(val,(void**) &x,
-                                    $descriptor(T *), 0) != 0) {
-                        if (!scm_is_pair(val))
-                            SWIG_exception(SWIG_TypeError,"alist expected");
-                        val = SCM_CAR(val);
-                        x = (T*) SWIG_MustGetPtr(val,$descriptor(T *),$argnum, 0);
-                    }
-                    temp[*k] = *x;
-                    alist = SCM_CDR(alist);
-                }
-            } else {
-                $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
-            }
-        }
-        %typemap(out) map<K,T> {
-            SCM alist = SCM_EOL;
-            for (std::map<K,T >::reverse_iterator i=$i.rbegin(); 
-                                                  i!=$i.rend(); ++i) {
-                K* key = new K(i->first);
-                T* val = new T(i->second);
-                SCM k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
-                SCM x = SWIG_NewPointerObj(val,$descriptor(T *), 1);
-                SCM entry = scm_cons(k,x);
-                alist = scm_cons(entry,alist);
-            }
-            $result = alist;
-        }
-        %typecheck(SWIG_TYPECHECK_MAP) map<K,T> {
-            /* native sequence? */
-            if (scm_is_null($input)) {
-                /* an empty sequence can be of any type */
-                $1 = 1;
-            } else if (scm_is_pair($input)) {
-                /* check the first element only */
-                K* k;
-                T* x;
-                SCM head = SCM_CAR($input);
-                if (scm_is_pair(head)) {
-                    SCM key = SCM_CAR(head);
-                    SCM val = SCM_CDR(head);
-                    if (SWIG_ConvertPtr(key,(void**) &k,
-                                    $descriptor(K *), 0) != 0) {
-                        $1 = 0;
-                    } else {
-                        if (SWIG_ConvertPtr(val,(void**) &x,
-                                        $descriptor(T *), 0) == 0) {
-                            $1 = 1;
-                        } else if (scm_is_pair(val)) {
-                            val = SCM_CAR(val);
-                            if (SWIG_ConvertPtr(val,(void**) &x,
-                                            $descriptor(T *), 0) == 0)
-                                $1 = 1;
-                            else
-                                $1 = 0;
-                        } else {
-                            $1 = 0;
-                        }
-                    }
-                } else {
-                    $1 = 0;
-                }
-            } else {
-                /* wrapped map? */
-                std::map<K,T >* m;
-                if (SWIG_ConvertPtr($input,(void **) &m,
-                                $&1_descriptor, 0) == 0)
-                    $1 = 1;
-                else
-                    $1 = 0;
-            }
-        }
-        %typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&,
-                                       const map<K,T>* {
-            /* native sequence? */
-            if (scm_is_null($input)) {
-                /* an empty sequence can be of any type */
-                $1 = 1;
-            } else if (scm_is_pair($input)) {
-                /* check the first element only */
-                K* k;
-                T* x;
-                SCM head = SCM_CAR($input);
-                if (scm_is_pair(head)) {
-                    SCM key = SCM_CAR(head);
-                    SCM val = SCM_CDR(head);
-                    if (SWIG_ConvertPtr(key,(void**) &k,
-                                    $descriptor(K *), 0) != 0) {
-                        $1 = 0;
-                    } else {
-                        if (SWIG_ConvertPtr(val,(void**) &x,
-                                        $descriptor(T *), 0) == 0) {
-                            $1 = 1;
-                        } else if (scm_is_pair(val)) {
-                            val = SCM_CAR(val);
-                            if (SWIG_ConvertPtr(val,(void**) &x,
-                                            $descriptor(T *), 0) == 0)
-                                $1 = 1;
-                            else
-                                $1 = 0;
-                        } else {
-                            $1 = 0;
-                        }
-                    }
-                } else {
-                    $1 = 0;
-                }
-            } else {
-                /* wrapped map? */
-                std::map<K,T >* m;
-                if (SWIG_ConvertPtr($input,(void **) &m,
-                                $1_descriptor, 0) == 0)
-                    $1 = 1;
-                else
-                    $1 = 0;
-            }
-        }
-        %rename("length") size;
-        %rename("null?") empty;
-        %rename("clear!") clear;
-        %rename("ref") __getitem__;
-        %rename("set!") __setitem__;
-        %rename("delete!") __delitem__;
-        %rename("has-key?") has_key;
-      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& __getitem__(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 __setitem__(const K& key, const T& x) {
-                (*self)[key] = x;
-            }
-            void __delitem__(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();
-            }
-            SCM keys() {
-                SCM result = SCM_EOL;
-                for (std::map<K,T >::reverse_iterator i=self->rbegin(); 
-                                                      i!=self->rend(); ++i) {
-                    K* key = new K(i->first);
-                    SCM k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
-                    result = scm_cons(k,result);
-                }
-                return result;
-            }
-        }
-    };
-
-
-    // specializations for built-ins
-
-    %define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO)
-
-    template<class T> class map<K,T> {
-        %typemap(in) map<K,T> (std::map<K,T>* m) {
-            if (scm_is_null($input)) {
-                $1 = std::map<K,T >();
-            } else if (scm_is_pair($input)) {
-                $1 = std::map<K,T >();
-                SCM alist = $input;
-                while (!scm_is_null(alist)) {
-                    T* x;
-                    SCM entry, key, val;
-                    entry = SCM_CAR(alist);
-                    if (!scm_is_pair(entry))
-                        SWIG_exception(SWIG_TypeError,"alist expected");
-                    key = SCM_CAR(entry);
-                    val = SCM_CDR(entry);
-                    if (!CHECK(key))
-                        SWIG_exception(SWIG_TypeError,
-                                       "map<" #K "," #T "> expected");
-                    if (SWIG_ConvertPtr(val,(void**) &x,
-                                    $descriptor(T *), 0) != 0) {
-                        if (!scm_is_pair(val))
-                            SWIG_exception(SWIG_TypeError,"alist expected");
-                        val = SCM_CAR(val);
-                        x = (T*) SWIG_MustGetPtr(val,$descriptor(T *),$argnum, 0);
-                    }
-                    (($1_type &)$1)[CONVERT_FROM(key)] = *x;
-                    alist = SCM_CDR(alist);
-                }
-            } else {
-                $1 = *(($&1_type)
-                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
-            }
-        }
-        %typemap(in) const map<K,T>& (std::map<K,T> temp,
-                                      std::map<K,T>* m),
-                     const map<K,T>* (std::map<K,T> temp,
-                                      std::map<K,T>* m) {
-            if (scm_is_null($input)) {
-                temp = std::map<K,T >();
-                $1 = &temp;
-            } else if (scm_is_pair($input)) {
-                temp = std::map<K,T >();
-                $1 = &temp;
-                SCM alist = $input;
-                while (!scm_is_null(alist)) {
-                    T* x;
-                    SCM entry, key, val;
-                    entry = SCM_CAR(alist);
-                    if (!scm_is_pair(entry))
-                        SWIG_exception(SWIG_TypeError,"alist expected");
-                    key = SCM_CAR(entry);
-                    val = SCM_CDR(entry);
-                    if (!CHECK(key))
-                        SWIG_exception(SWIG_TypeError,
-                                       "map<" #K "," #T "> expected");
-                    if (SWIG_ConvertPtr(val,(void**) &x,
-                                    $descriptor(T *), 0) != 0) {
-                        if (!scm_is_pair(val))
-                            SWIG_exception(SWIG_TypeError,"alist expected");
-                        val = SCM_CAR(val);
-                        x = (T*) SWIG_MustGetPtr(val,$descriptor(T *),$argnum, 0);
-                    }
-                    temp[CONVERT_FROM(key)] = *x;
-                    alist = SCM_CDR(alist);
-                }
-            } else {
-                $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
-            }
-        }
-        %typemap(out) map<K,T> {
-            SCM alist = SCM_EOL;
-            for (std::map<K,T >::reverse_iterator i=$1.rbegin(); 
-                                                  i!=$1.rend(); ++i) {
-                T* val = new T(i->second);
-                SCM k = CONVERT_TO(i->first);
-                SCM x = SWIG_NewPointerObj(val,$descriptor(T *), 1);
-                SCM entry = scm_cons(k,x);
-                alist = scm_cons(entry,alist);
-            }
-            $result = alist;
-        }
-        %typecheck(SWIG_TYPECHECK_MAP) map<K,T> {
-            // native sequence?
-            if (scm_is_null($input)) {
-                /* an empty sequence can be of any type */
-                $1 = 1;
-            } else if (scm_is_pair($input)) {
-                // check the first element only
-                T* x;
-                SCM head = SCM_CAR($input);
-                if (scm_is_pair(head)) {
-                    SCM key = SCM_CAR(head);
-                    SCM val = SCM_CDR(head);
-                    if (!CHECK(key)) {
-                        $1 = 0;
-                    } else {
-                        if (SWIG_ConvertPtr(val,(void**) &x,
-                                        $descriptor(T *), 0) == 0) {
-                            $1 = 1;
-                        } else if (scm_is_pair(val)) {
-                            val = SCM_CAR(val);
-                            if (SWIG_ConvertPtr(val,(void**) &x,
-                                            $descriptor(T *), 0) == 0)
-                                $1 = 1;
-                            else
-                                $1 = 0;
-                        } else {
-                            $1 = 0;
-                        }
-                    }
-                } else {
-                    $1 = 0;
-                }
-            } else {
-                // wrapped map?
-                std::map<K,T >* m;
-                if (SWIG_ConvertPtr($input,(void **) &m,
-                                $&1_descriptor, 0) == 0)
-                    $1 = 1;
-                else
-                    $1 = 0;
-            }
-        }
-        %typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&,
-                                       const map<K,T>* {
-            // native sequence?
-            if (scm_is_null($input)) {
-                /* an empty sequence can be of any type */
-                $1 = 1;
-            } else if (scm_is_pair($input)) {
-                // check the first element only
-                T* x;
-                SCM head = SCM_CAR($input);
-                if (scm_is_pair(head)) {
-                    SCM key = SCM_CAR(head);
-                    SCM val = SCM_CDR(head);
-                    if (!CHECK(key)) {
-                        $1 = 0;
-                    } else {
-                        if (SWIG_ConvertPtr(val,(void**) &x,
-                                        $descriptor(T *), 0) == 0) {
-                            $1 = 1;
-                        } else if (scm_is_pair(val)) {
-                            val = SCM_CAR(val);
-                            if (SWIG_ConvertPtr(val,(void**) &x,
-                                            $descriptor(T *), 0) == 0)
-                                $1 = 1;
-                            else
-                                $1 = 0;
-                        } else {
-                            $1 = 0;
-                        }
-                    }
-                } else {
-                    $1 = 0;
-                }
-            } else {
-                // wrapped map?
-                std::map<K,T >* m;
-                if (SWIG_ConvertPtr($input,(void **) &m,
-                                $1_descriptor, 0) == 0)
-                    $1 = 1;
-                else
-                    $1 = 0;
-            }
-        }
-        %rename("length") size;
-        %rename("null?") empty;
-        %rename("clear!") clear;
-        %rename("ref") __getitem__;
-        %rename("set!") __setitem__;
-        %rename("delete!") __delitem__;
-        %rename("has-key?") has_key;
-      public:
-        map();
-        map(const map<K,T> &);
-        
-        unsigned int size() const;
-        bool empty() const;
-        void clear();
-        %extend {
-            T& __getitem__(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 __setitem__(K key, const T& x) {
-                (*self)[key] = x;
-            }
-            void __delitem__(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(K key) {
-                std::map<K,T >::iterator i = self->find(key);
-                return i != self->end();
-            }
-            SCM keys() {
-                SCM result = SCM_EOL;
-                for (std::map<K,T >::reverse_iterator i=self->rbegin(); 
-                                                      i!=self->rend(); ++i) {
-                    SCM k = CONVERT_TO(i->first);
-                    result = scm_cons(k,result);
-                }
-                return result;
-            }
-        }
-    };
-    %enddef
-
-    %define specialize_std_map_on_value(T,CHECK,CONVERT_FROM,CONVERT_TO)
-    template<class K> class map<K,T> {
-        %typemap(in) map<K,T> (std::map<K,T>* m) {
-            if (scm_is_null($input)) {
-                $1 = std::map<K,T >();
-            } else if (scm_is_pair($input)) {
-                $1 = std::map<K,T >();
-                SCM alist = $input;
-                while (!scm_is_null(alist)) {
-                    K* k;
-                    SCM entry, key, val;
-                    entry = SCM_CAR(alist);
-                    if (!scm_is_pair(entry))
-                        SWIG_exception(SWIG_TypeError,"alist expected");
-                    key = SCM_CAR(entry);
-                    val = SCM_CDR(entry);
-                    k = (K*) SWIG_MustGetPtr(key,$descriptor(K *),$argnum, 0);
-                    if (!CHECK(val)) {
-                        if (!scm_is_pair(val))
-                            SWIG_exception(SWIG_TypeError,"alist expected");
-                        val = SCM_CAR(val);
-                        if (!CHECK(val))
-                            SWIG_exception(SWIG_TypeError,
-                                           "map<" #K "," #T "> expected");
-                    }
-                    (($1_type &)$1)[*k] = CONVERT_FROM(val);
-                    alist = SCM_CDR(alist);
-                }
-            } else {
-                $1 = *(($&1_type)
-                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
-            }
-        }
-        %typemap(in) const map<K,T>& (std::map<K,T> temp,
-                                      std::map<K,T>* m),
-                     const map<K,T>* (std::map<K,T> temp,
-                                      std::map<K,T>* m) {
-            if (scm_is_null($input)) {
-                temp = std::map<K,T >();
-                $1 = &temp;
-            } else if (scm_is_pair($input)) {
-                temp = std::map<K,T >();
-                $1 = &temp;
-                SCM alist = $input;
-                while (!scm_is_null(alist)) {
-                    K* k;
-                    SCM entry, key, val;
-                    entry = SCM_CAR(alist);
-                    if (!scm_is_pair(entry))
-                        SWIG_exception(SWIG_TypeError,"alist expected");
-                    key = SCM_CAR(entry);
-                    val = SCM_CDR(entry);
-                    k = (K*) SWIG_MustGetPtr(key,$descriptor(K *),$argnum, 0);
-                    if (!CHECK(val)) {
-                        if (!scm_is_pair(val))
-                            SWIG_exception(SWIG_TypeError,"alist expected");
-                        val = SCM_CAR(val);
-                        if (!CHECK(val))
-                            SWIG_exception(SWIG_TypeError,
-                                           "map<" #K "," #T "> expected");
-                    }
-                    temp[*k] = CONVERT_FROM(val);
-                    alist = SCM_CDR(alist);
-                }
-            } else {
-                $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
-            }
-        }
-        %typemap(out) map<K,T> {
-            SCM alist = SCM_EOL;
-            for (std::map<K,T >::reverse_iterator i=$1.rbegin(); 
-                                                  i!=$1.rend(); ++i) {
-                K* key = new K(i->first);
-                SCM k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
-                SCM x = CONVERT_TO(i->second);
-                SCM entry = scm_cons(k,x);
-                alist = scm_cons(entry,alist);
-            }
-            $result = alist;
-        }
-        %typecheck(SWIG_TYPECHECK_MAP) map<K,T> {
-            // native sequence?
-            if (scm_is_null($input)) {
-                /* an empty sequence can be of any type */
-                $1 = 1;
-            } else if (scm_is_pair($input)) {
-                // check the first element only
-                K* k;
-                SCM head = SCM_CAR($input);
-                if (scm_is_pair(head)) {
-                    SCM key = SCM_CAR(head);
-                    SCM val = SCM_CDR(head);
-                    if (SWIG_ConvertPtr(val,(void **) &k,
-                                    $descriptor(K *), 0) != 0) {
-                        $1 = 0;
-                    } else {
-                        if (CHECK(val)) {
-                            $1 = 1;
-                        } else if (scm_is_pair(val)) {
-                            val = SCM_CAR(val);
-                            if (CHECK(val))
-                                $1 = 1;
-                            else
-                                $1 = 0;
-                        } else {
-                            $1 = 0;
-                        }
-                    }
-                } else {
-                    $1 = 0;
-                }
-            } else {
-                // wrapped map?
-                std::map<K,T >* m;
-                if (SWIG_ConvertPtr($input,(void **) &m,
-                                $&1_descriptor, 0) == 0)
-                    $1 = 1;
-                else
-                    $1 = 0;
-            }
-        }
-        %typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&,
-                                       const map<K,T>* {
-            // native sequence?
-            if (scm_is_null($input)) {
-                /* an empty sequence can be of any type */
-                $1 = 1;
-            } else if (scm_is_pair($input)) {
-                // check the first element only
-                K* k;
-                SCM head = SCM_CAR($input);
-                if (scm_is_pair(head)) {
-                    SCM key = SCM_CAR(head);
-                    SCM val = SCM_CDR(head);
-                    if (SWIG_ConvertPtr(val,(void **) &k,
-                                    $descriptor(K *), 0) != 0) {
-                        $1 = 0;
-                    } else {
-                        if (CHECK(val)) {
-                            $1 = 1;
-                        } else if (scm_is_pair(val)) {
-                            val = SCM_CAR(val);
-                            if (CHECK(val))
-                                $1 = 1;
-                            else
-                                $1 = 0;
-                        } else {
-                            $1 = 0;
-                        }
-                    }
-                } else {
-                    $1 = 0;
-                }
-            } else {
-                // wrapped map?
-                std::map<K,T >* m;
-                if (SWIG_ConvertPtr($input,(void **) &m,
-                                $1_descriptor, 0) == 0)
-                    $1 = 1;
-                else
-                    $1 = 0;
-            }
-        }
-        %rename("length") size;
-        %rename("null?") empty;
-        %rename("clear!") clear;
-        %rename("ref") __getitem__;
-        %rename("set!") __setitem__;
-        %rename("delete!") __delitem__;
-        %rename("has-key?") has_key;
-      public:
-        map();
-        map(const map<K,T> &);
-        
-        unsigned int size() const;
-        bool empty() const;
-        void clear();
-        %extend {
-            T __getitem__(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 __setitem__(const K& key, T x) {
-                (*self)[key] = x;
-            }
-            void __delitem__(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();
-            }
-            SCM keys() {
-                SCM result = SCM_EOL;
-                for (std::map<K,T >::reverse_iterator i=self->rbegin(); 
-                                                      i!=self->rend(); ++i) {
-                    K* key = new K(i->first);
-                    SCM k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
-                    result = scm_cons(k,result);
-                }
-                return result;
-            }
-        }
-    };
-    %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)
-    template<> class map<K,T> {
-        %typemap(in) map<K,T> (std::map<K,T>* m) {
-            if (scm_is_null($input)) {
-                $1 = std::map<K,T >();
-            } else if (scm_is_pair($input)) {
-                $1 = std::map<K,T >();
-                SCM alist = $input;
-                while (!scm_is_null(alist)) {
-                    SCM entry, key, val;
-                    entry = SCM_CAR(alist);
-                    if (!scm_is_pair(entry))
-                        SWIG_exception(SWIG_TypeError,"alist expected");
-                    key = SCM_CAR(entry);
-                    val = SCM_CDR(entry);
-                    if (!CHECK_K(key))
-                        SWIG_exception(SWIG_TypeError,
-                                           "map<" #K "," #T "> expected");
-                    if (!CHECK_T(val)) {
-                        if (!scm_is_pair(val))
-                            SWIG_exception(SWIG_TypeError,"alist expected");
-                        val = SCM_CAR(val);
-                        if (!CHECK_T(val))
-                            SWIG_exception(SWIG_TypeError,
-                                           "map<" #K "," #T "> expected");
-                    }
-                    (($1_type &)$1)[CONVERT_K_FROM(key)] = 
-                                               CONVERT_T_FROM(val);
-                    alist = SCM_CDR(alist);
-                }
-            } else {
-                $1 = *(($&1_type)
-                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
-            }
-        }
-        %typemap(in) const map<K,T>& (std::map<K,T> temp,
-                                      std::map<K,T>* m),
-                     const map<K,T>* (std::map<K,T> temp,
-                                      std::map<K,T>* m) {
-            if (scm_is_null($input)) {
-                temp = std::map<K,T >();
-                $1 = &temp;
-            } else if (scm_is_pair($input)) {
-                temp = std::map<K,T >();
-                $1 = &temp;
-                SCM alist = $input;
-                while (!scm_is_null(alist)) {
-                    SCM entry, key, val;
-                    entry = SCM_CAR(alist);
-                    if (!scm_is_pair(entry))
-                        SWIG_exception(SWIG_TypeError,"alist expected");
-                    key = SCM_CAR(entry);
-                    val = SCM_CDR(entry);
-                    if (!CHECK_K(key))
-                        SWIG_exception(SWIG_TypeError,
-                                           "map<" #K "," #T "> expected");
-                    if (!CHECK_T(val)) {
-                        if (!scm_is_pair(val))
-                            SWIG_exception(SWIG_TypeError,"alist expected");
-                        val = SCM_CAR(val);
-                        if (!CHECK_T(val))
-                            SWIG_exception(SWIG_TypeError,
-                                           "map<" #K "," #T "> expected");
-                    }
-                    temp[CONVERT_K_FROM(key)] = CONVERT_T_FROM(val);
-                    alist = SCM_CDR(alist);
-                }
-            } else {
-                $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
-            }
-        }
-        %typemap(out) map<K,T> {
-            SCM alist = SCM_EOL;
-            for (std::map<K,T >::reverse_iterator i=$1.rbegin(); 
-                                                  i!=$1.rend(); ++i) {
-                SCM k = CONVERT_K_TO(i->first);
-                SCM x = CONVERT_T_TO(i->second);
-                SCM entry = scm_cons(k,x);
-                alist = scm_cons(entry,alist);
-            }
-            $result = alist;
-        }
-        %typecheck(SWIG_TYPECHECK_MAP) map<K,T> {
-            // native sequence?
-            if (scm_is_null($input)) {
-                /* an empty sequence can be of any type */
-                $1 = 1;
-            } else if (scm_is_pair($input)) {
-                // check the first element only
-                SCM head = SCM_CAR($input);
-                if (scm_is_pair(head)) {
-                    SCM key = SCM_CAR(head);
-                    SCM val = SCM_CDR(head);
-                    if (!CHECK_K(key)) {
-                        $1 = 0;
-                    } else {
-                        if (CHECK_T(val)) {
-                            $1 = 1;
-                        } else if (scm_is_pair(val)) {
-                            val = SCM_CAR(val);
-                            if (CHECK_T(val))
-                                $1 = 1;
-                            else
-                                $1 = 0;
-                        } else {
-                            $1 = 0;
-                        }
-                    }
-                } else {
-                    $1 = 0;
-                }
-            } else {
-                // wrapped map?
-                std::map<K,T >* m;
-                if (SWIG_ConvertPtr($input,(void **) &m,
-                                $&1_descriptor, 0) == 0)
-                    $1 = 1;
-                else
-                    $1 = 0;
-            }
-        }
-        %typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&,
-                                       const map<K,T>* {
-            // native sequence?
-            if (scm_is_null($input)) {
-                /* an empty sequence can be of any type */
-                $1 = 1;
-            } else if (scm_is_pair($input)) {
-                // check the first element only
-                SCM head = SCM_CAR($input);
-                if (scm_is_pair(head)) {
-                    SCM key = SCM_CAR(head);
-                    SCM val = SCM_CDR(head);
-                    if (!CHECK_K(key)) {
-                        $1 = 0;
-                    } else {
-                        if (CHECK_T(val)) {
-                            $1 = 1;
-                        } else if (scm_is_pair(val)) {
-                            val = SCM_CAR(val);
-                            if (CHECK_T(val))
-                                $1 = 1;
-                            else
-                                $1 = 0;
-                        } else {
-                            $1 = 0;
-                        }
-                    }
-                } else {
-                    $1 = 0;
-                }
-            } else {
-                // wrapped map?
-                std::map<K,T >* m;
-                if (SWIG_ConvertPtr($input,(void **) &m,
-                                $1_descriptor, 0) == 0)
-                    $1 = 1;
-                else
-                    $1 = 0;
-            }
-        }
-        %rename("length") size;
-        %rename("null?") empty;
-        %rename("clear!") clear;
-        %rename("ref") __getitem__;
-        %rename("set!") __setitem__;
-        %rename("delete!") __delitem__;
-        %rename("has-key?") has_key;
-      public:
-        map();
-        map(const map<K,T> &);
-        
-        unsigned int size() const;
-        bool empty() const;
-        void clear();
-        %extend {
-            T __getitem__(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 __setitem__(K key, T x) {
-                (*self)[key] = x;
-            }
-            void __delitem__(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(K key) {
-                std::map<K,T >::iterator i = self->find(key);
-                return i != self->end();
-            }
-            SCM keys() {
-                SCM result = SCM_EOL;
-                for (std::map<K,T >::reverse_iterator i=self->rbegin(); 
-                                                      i!=self->rend(); ++i) {
-                    SCM k = CONVERT_K_TO(i->first);
-                    result = scm_cons(k,result);
-                }
-                return result;
-            }
-        }
-    };
-    %enddef
-
-
-    specialize_std_map_on_key(bool,scm_is_bool,
-                              scm_is_true,SWIG_bool2scm);
-    specialize_std_map_on_key(int,scm_is_number,
-                              scm_to_long,scm_from_long);
-    specialize_std_map_on_key(short,scm_is_number,
-                              scm_to_long,scm_from_long);
-    specialize_std_map_on_key(long,scm_is_number,
-                              scm_to_long,scm_from_long);
-    specialize_std_map_on_key(unsigned int,scm_is_number,
-                              scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_key(unsigned short,scm_is_number,
-                              scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_key(unsigned long,scm_is_number,
-                              scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_key(double,scm_is_number,
-                              scm_to_double,scm_from_double);
-    specialize_std_map_on_key(float,scm_is_number,
-                              scm_to_double,scm_from_double);
-    specialize_std_map_on_key(std::string,scm_is_string,
-                              SWIG_scm2string,SWIG_string2scm);
-
-    specialize_std_map_on_value(bool,scm_is_bool,
-                                scm_is_true,SWIG_bool2scm);
-    specialize_std_map_on_value(int,scm_is_number,
-                                scm_to_long,scm_from_long);
-    specialize_std_map_on_value(short,scm_is_number,
-                                scm_to_long,scm_from_long);
-    specialize_std_map_on_value(long,scm_is_number,
-                                scm_to_long,scm_from_long);
-    specialize_std_map_on_value(unsigned int,scm_is_number,
-                                scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_value(unsigned short,scm_is_number,
-                                scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_value(unsigned long,scm_is_number,
-                                scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_value(double,scm_is_number,
-                                scm_to_double,scm_from_double);
-    specialize_std_map_on_value(float,scm_is_number,
-                                scm_to_double,scm_from_double);
-    specialize_std_map_on_value(std::string,scm_is_string,
-                                SWIG_scm2string,SWIG_string2scm);
-
-    specialize_std_map_on_both(bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm,
-                               bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm);
-    specialize_std_map_on_both(bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm,
-                               int,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm,
-                               short,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm,
-                               long,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm,
-                               unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm,
-                               unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm,
-                               unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm,
-                               double,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_map_on_both(bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm,
-                               float,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_map_on_both(bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm,
-                               std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm);
-    specialize_std_map_on_both(int,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm);
-    specialize_std_map_on_both(int,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               int,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(int,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               short,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(int,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               long,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(int,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(int,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(int,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(int,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               double,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_map_on_both(int,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               float,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_map_on_both(int,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm);
-    specialize_std_map_on_both(short,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm);
-    specialize_std_map_on_both(short,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               int,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(short,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               short,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(short,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               long,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(short,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(short,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(short,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(short,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               double,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_map_on_both(short,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               float,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_map_on_both(short,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm);
-    specialize_std_map_on_both(long,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm);
-    specialize_std_map_on_both(long,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               int,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(long,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               short,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(long,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               long,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(long,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(long,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(long,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(long,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               double,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_map_on_both(long,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               float,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_map_on_both(long,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm);
-    specialize_std_map_on_both(unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm);
-    specialize_std_map_on_both(unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               int,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               short,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               long,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               double,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_map_on_both(unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               float,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_map_on_both(unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm);
-    specialize_std_map_on_both(unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm);
-    specialize_std_map_on_both(unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               int,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               short,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               long,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               double,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_map_on_both(unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               float,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_map_on_both(unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm);
-    specialize_std_map_on_both(unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm);
-    specialize_std_map_on_both(unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               int,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               short,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               long,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               double,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_map_on_both(unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               float,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_map_on_both(unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm);
-    specialize_std_map_on_both(double,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm);
-    specialize_std_map_on_both(double,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               int,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(double,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               short,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(double,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               long,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(double,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(double,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(double,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(double,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               double,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_map_on_both(double,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               float,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_map_on_both(double,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm);
-    specialize_std_map_on_both(float,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm);
-    specialize_std_map_on_both(float,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               int,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(float,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               short,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(float,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               long,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(float,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(float,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(float,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(float,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               double,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_map_on_both(float,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               float,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_map_on_both(float,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm);
-    specialize_std_map_on_both(std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm,
-                               bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm);
-    specialize_std_map_on_both(std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm,
-                               int,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm,
-                               short,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm,
-                               long,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_map_on_both(std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm,
-                               unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm,
-                               unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm,
-                               unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_map_on_both(std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm,
-                               double,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_map_on_both(std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm,
-                               float,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_map_on_both(std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm,
-                               std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm);
-}
diff --git a/share/swig/2.0.11/guile/std_pair.i b/share/swig/2.0.11/guile/std_pair.i
deleted file mode 100644
index 512d0d5..0000000
--- a/share/swig/2.0.11/guile/std_pair.i
+++ /dev/null
@@ -1,863 +0,0 @@
-/* -----------------------------------------------------------------------------
- * std_pair.i
- *
- * SWIG typemaps for std::pair
- * ----------------------------------------------------------------------------- */
-
-%include <std_common.i>
-%include <exception.i>
-
-// ------------------------------------------------------------------------
-// std::pair
-//
-// See std_vector.i for the rationale of typemap application
-// ------------------------------------------------------------------------
-
-%{
-#include <utility>
-%}
-
-// exported class
-
-namespace std {
-
-    template<class T, class U> struct pair {
-        %typemap(in) pair<T,U> %{
-            if (scm_is_pair($input)) {
-                T* x;
-                U* y;
-                SCM first, second;
-                first = SCM_CAR($input);
-                second = SCM_CDR($input);
-                x = (T*) SWIG_MustGetPtr(first,$descriptor(T *),$argnum, 0);
-                y = (U*) SWIG_MustGetPtr(second,$descriptor(U *),$argnum, 0);
-                $1 = std::make_pair(*x,*y);
-            } else {
-                $1 = *(($&1_type)
-                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
-            }
-        %}
-        %typemap(in) const pair<T,U>& (std::pair<T,U> *temp = 0),
-                     const pair<T,U>* (std::pair<T,U> *temp = 0) %{
-            if (scm_is_pair($input)) {
-                T* x;
-                U* y;
-                SCM first, second;
-                first = SCM_CAR($input);
-                second = SCM_CDR($input);
-                x = (T*) SWIG_MustGetPtr(first,$descriptor(T *),$argnum, 0);
-                y = (U*) SWIG_MustGetPtr(second,$descriptor(U *),$argnum, 0);
-                temp = new std::pair< T, U >(*x,*y);
-                $1 = temp;
-            } else {
-                $1 = ($1_ltype)
-                    SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
-            }
-        %}
-        %typemap(freearg) const pair<T,U>&, const pair<T,U>* %{ delete temp$argnum; %}
-        %typemap(out) pair<T,U> {
-            T* x = new T($1.first);
-            U* y = new U($1.second);
-            SCM first = SWIG_NewPointerObj(x,$descriptor(T *), 1);
-            SCM second = SWIG_NewPointerObj(y,$descriptor(U *), 1);
-            $result = scm_cons(first,second);
-        }
-        %typecheck(SWIG_TYPECHECK_PAIR) pair<T,U> {
-            /* native pair? */
-            if (scm_is_pair($input)) {
-                T* x;
-                U* y;
-                SCM first = SCM_CAR($input);
-                SCM second = SCM_CDR($input);
-                if (SWIG_ConvertPtr(first,(void**) &x,
-                                    $descriptor(T *), 0) == 0 &&
-                    SWIG_ConvertPtr(second,(void**) &y,
-                                    $descriptor(U *), 0) == 0) {
-                    $1 = 1;
-                } else {
-                    $1 = 0;
-                }
-            } else {
-                /* wrapped pair? */
-                std::pair<T,U >* m;
-                if (SWIG_ConvertPtr($input,(void **) &m,
-                                    $&1_descriptor, 0) == 0)
-                    $1 = 1;
-                else
-                    $1 = 0;
-            }
-        }
-        %typecheck(SWIG_TYPECHECK_PAIR) const pair<T,U>&,
-                                        const pair<T,U>* {
-            /* native pair? */
-            if (scm_is_pair($input)) {
-                T* x;
-                U* y;
-                SCM first = SCM_CAR($input);
-                SCM second = SCM_CDR($input);
-                if (SWIG_ConvertPtr(first,(void**) &x,
-                                    $descriptor(T *), 0) == 0 &&
-                    SWIG_ConvertPtr(second,(void**) &y,
-                                    $descriptor(U *), 0) == 0) {
-                    $1 = 1;
-                } else {
-                    $1 = 0;
-                }
-            } else {
-                /* wrapped pair? */
-                std::pair<T,U >* m;
-                if (SWIG_ConvertPtr($input,(void **) &m,
-                                    $1_descriptor, 0) == 0)
-                    $1 = 1;
-                else
-                    $1 = 0;
-            }
-        }
-        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;
-    };
-
-
-    // specializations for built-ins
-
-    %define specialize_std_pair_on_first(T,CHECK,CONVERT_FROM,CONVERT_TO)
-    template<class U> struct pair<T,U> {
-        %typemap(in) pair<T,U> %{
-            if (scm_is_pair($input)) {
-                U* y;
-                SCM first, second;
-                first = SCM_CAR($input);
-                second = SCM_CDR($input);
-                if (!CHECK(first))
-                    SWIG_exception(SWIG_TypeError,
-                                   "pair<" #T "," #U "> expected");
-                y = (U*) SWIG_MustGetPtr(second,$descriptor(U *),$argnum, 0);
-                $1 = std::make_pair(CONVERT_FROM(first),*y);
-            } else {
-                $1 = *(($&1_type)
-                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
-            }
-        %}
-        %typemap(in) const pair<T,U>& (std::pair<T,U> *temp = 0),
-                     const pair<T,U>* (std::pair<T,U> *temp = 0) %{
-            if (scm_is_pair($input)) {
-                U* y;
-                SCM first, second;
-                first = SCM_CAR($input);
-                second = SCM_CDR($input);
-                if (!CHECK(first))
-                    SWIG_exception(SWIG_TypeError,
-                                   "pair<" #T "," #U "> expected");
-                y = (U*) SWIG_MustGetPtr(second,$descriptor(U *),$argnum, 0);
-                temp = new std::pair< T, U >(CONVERT_FROM(first),*y);
-                $1 = temp;
-            } else {
-                $1 = ($1_ltype)
-                    SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
-            }
-        %}
-        %typemap(freearg) const pair<T,U>&, const pair<T,U>* %{ delete temp$argnum; %}
-        %typemap(out) pair<T,U> {
-            U* y = new U($1.second);
-            SCM second = SWIG_NewPointerObj(y,$descriptor(U *), 1);
-            $result = scm_cons(CONVERT_TO($1.first),second);
-        }
-        %typecheck(SWIG_TYPECHECK_PAIR) pair<T,U> {
-            /* native pair? */
-            if (scm_is_pair($input)) {
-                U* y;
-                SCM first = SCM_CAR($input);
-                SCM second = SCM_CDR($input);
-                if (CHECK(first) &&
-                    SWIG_ConvertPtr(second,(void**) &y,
-                                    $descriptor(U *), 0) == 0) {
-                    $1 = 1;
-                } else {
-                    $1 = 0;
-                }
-            } else {
-                /* wrapped pair? */
-                std::pair<T,U >* m;
-                if (SWIG_ConvertPtr($input,(void **) &m,
-                                    $&1_descriptor, 0) == 0)
-                    $1 = 1;
-                else
-                    $1 = 0;
-            }
-        }
-        %typecheck(SWIG_TYPECHECK_PAIR) const pair<T,U>&,
-                                        const pair<T,U>* {
-            /* native pair? */
-            if (scm_is_pair($input)) {
-                U* y;
-                SCM first = SCM_CAR($input);
-                SCM second = SCM_CDR($input);
-                if (CHECK(first) &&
-                    SWIG_ConvertPtr(second,(void**) &y,
-                                    $descriptor(U *), 0) == 0) {
-                    $1 = 1;
-                } else {
-                    $1 = 0;
-                }
-            } else {
-                /* wrapped pair? */
-                std::pair<T,U >* m;
-                if (SWIG_ConvertPtr($input,(void **) &m,
-                                    $1_descriptor, 0) == 0)
-                    $1 = 1;
-                else
-                    $1 = 0;
-            }
-        }
-        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;
-    };
-    %enddef
-
-    %define specialize_std_pair_on_second(U,CHECK,CONVERT_FROM,CONVERT_TO)
-    template<class T> struct pair<T,U> {
-        %typemap(in) pair<T,U> %{
-            if (scm_is_pair($input)) {
-                T* x;
-                SCM first, second;
-                first = SCM_CAR($input);
-                second = SCM_CDR($input);
-                x = (T*) SWIG_MustGetPtr(first,$descriptor(T *),$argnum, 0);
-                if (!CHECK(second))
-                    SWIG_exception(SWIG_TypeError,
-                                   "pair<" #T "," #U "> expected");
-                $1 = std::make_pair(*x,CONVERT_FROM(second));
-            } else {
-                $1 = *(($&1_type)
-                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
-            }
-        %}
-        %typemap(in) const pair<T,U>& (std::pair<T,U> *temp = 0),
-                     const pair<T,U>* (std::pair<T,U> *temp = 0) %{
-            if (scm_is_pair($input)) {
-                T* x;
-                SCM first, second;
-                first = SCM_CAR($input);
-                second = SCM_CDR($input);
-                x = (T*) SWIG_MustGetPtr(first,$descriptor(T *),$argnum, 0);
-                if (!CHECK(second))
-                    SWIG_exception(SWIG_TypeError,
-                                   "pair<" #T "," #U "> expected");
-                temp = new std::pair< T, U >(*x,CONVERT_FROM(second));
-                $1 = temp;
-            } else {
-                $1 = ($1_ltype)
-                    SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
-            }
-        %}
-        %typemap(freearg) const pair<T,U>&, const pair<T,U>* %{ delete temp$argnum; %}
-        %typemap(out) pair<T,U> {
-            T* x = new T($1.first);
-            SCM first = SWIG_NewPointerObj(x,$descriptor(T *), 1);
-            $result = scm_cons(first,CONVERT_TO($1.second));
-        }
-        %typecheck(SWIG_TYPECHECK_PAIR) pair<T,U> {
-            /* native pair? */
-            if (scm_is_pair($input)) {
-                T* x;
-                SCM first = SCM_CAR($input);
-                SCM second = SCM_CDR($input);
-                if (SWIG_ConvertPtr(first,(void**) &x,
-                                    $descriptor(T *), 0) == 0 &&
-                    CHECK(second)) {
-                    $1 = 1;
-                } else {
-                    $1 = 0;
-                }
-            } else {
-                /* wrapped pair? */
-                std::pair<T,U >* m;
-                if (SWIG_ConvertPtr($input,(void **) &m,
-                                    $&1_descriptor, 0) == 0)
-                    $1 = 1;
-                else
-                    $1 = 0;
-            }
-        }
-        %typecheck(SWIG_TYPECHECK_PAIR) const pair<T,U>&,
-                                        const pair<T,U>* {
-            /* native pair? */
-            if (scm_is_pair($input)) {
-                T* x;
-                SCM first = SCM_CAR($input);
-                SCM second = SCM_CDR($input);
-                if (SWIG_ConvertPtr(first,(void**) &x,
-                                    $descriptor(T *), 0) == 0 &&
-                    CHECK(second)) {
-                    $1 = 1;
-                } else {
-                    $1 = 0;
-                }
-            } else {
-                /* wrapped pair? */
-                std::pair<T,U >* m;
-                if (SWIG_ConvertPtr($input,(void **) &m,
-                                    $1_descriptor, 0) == 0)
-                    $1 = 1;
-                else
-                    $1 = 0;
-            }
-        }
-        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;
-    };
-    %enddef
-
-    %define specialize_std_pair_on_both(T,CHECK_T,CONVERT_T_FROM,CONVERT_T_TO,
-                                        U,CHECK_U,CONVERT_U_FROM,CONVERT_U_TO)
-    template<> struct pair<T,U> {
-        %typemap(in) pair<T,U> %{
-            if (scm_is_pair($input)) {
-                SCM first, second;
-                first = SCM_CAR($input);
-                second = SCM_CDR($input);
-                if (!CHECK_T(first) || !CHECK_U(second))
-                    SWIG_exception(SWIG_TypeError,
-                                   "pair<" #T "," #U "> expected");
-                $1 = std::make_pair(CONVERT_T_FROM(first),
-                                    CONVERT_U_FROM(second));
-            } else {
-                $1 = *(($&1_type)
-                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
-            }
-        %}
-        %typemap(in) const pair<T,U>& (std::pair<T,U> *temp = 0),
-                     const pair<T,U>* (std::pair<T,U> *temp = 0) %{
-            if (scm_is_pair($input)) {
-                SCM first, second;
-                first = SCM_CAR($input);
-                second = SCM_CDR($input);
-                if (!CHECK_T(first) || !CHECK_U(second))
-                    SWIG_exception(SWIG_TypeError,
-                                   "pair<" #T "," #U "> expected");
-                temp = new std::pair< T, U >(CONVERT_T_FROM(first), CONVERT_U_FROM(second));
-                $1 = temp;
-            } else {
-                $1 = ($1_ltype)
-                    SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
-            }
-        %}
-        %typemap(freearg) const pair<T,U>&, const pair<T,U>* %{ delete temp$argnum; %}
-        %typemap(out) pair<T,U> {
-            $result = scm_cons(CONVERT_T_TO($1.first),
-                              CONVERT_U_TO($1.second));
-        }
-        %typecheck(SWIG_TYPECHECK_PAIR) pair<T,U> {
-            /* native pair? */
-            if (scm_is_pair($input)) {
-                SCM first = SCM_CAR($input);
-                SCM second = SCM_CDR($input);
-                if (CHECK_T(first) && CHECK_U(second)) {
-                    $1 = 1;
-                } else {
-                    $1 = 0;
-                }
-            } else {
-                /* wrapped pair? */
-                std::pair<T,U >* m;
-                if (SWIG_ConvertPtr($input,(void **) &m,
-                                    $&1_descriptor, 0) == 0)
-                    $1 = 1;
-                else
-                    $1 = 0;
-            }
-        }
-        %typecheck(SWIG_TYPECHECK_PAIR) const pair<T,U>&,
-                                        const pair<T,U>* {
-            /* native pair? */
-            if (scm_is_pair($input)) {
-                SCM first = SCM_CAR($input);
-                SCM second = SCM_CDR($input);
-                if (CHECK_T(first) && CHECK_U(second)) {
-                    $1 = 1;
-                } else {
-                    $1 = 0;
-                }
-            } else {
-                /* wrapped pair? */
-                std::pair<T,U >* m;
-                if (SWIG_ConvertPtr($input,(void **) &m,
-                                    $1_descriptor, 0) == 0)
-                    $1 = 1;
-                else
-                    $1 = 0;
-            }
-        }
-        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;
-    };
-    %enddef
-
-
-    specialize_std_pair_on_first(bool,scm_is_bool,
-                              scm_is_true,SWIG_bool2scm);
-    specialize_std_pair_on_first(int,scm_is_number,
-                              scm_to_long,scm_from_long);
-    specialize_std_pair_on_first(short,scm_is_number,
-                              scm_to_long,scm_from_long);
-    specialize_std_pair_on_first(long,scm_is_number,
-                              scm_to_long,scm_from_long);
-    specialize_std_pair_on_first(unsigned int,scm_is_number,
-                              scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_first(unsigned short,scm_is_number,
-                              scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_first(unsigned long,scm_is_number,
-                              scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_first(double,scm_is_number,
-                              scm_to_double,scm_from_double);
-    specialize_std_pair_on_first(float,scm_is_number,
-                              scm_to_double,scm_from_double);
-    specialize_std_pair_on_first(std::string,scm_is_string,
-                              SWIG_scm2string,SWIG_string2scm);
-
-    specialize_std_pair_on_second(bool,scm_is_bool,
-                                scm_is_true,SWIG_bool2scm);
-    specialize_std_pair_on_second(int,scm_is_number,
-                                scm_to_long,scm_from_long);
-    specialize_std_pair_on_second(short,scm_is_number,
-                                scm_to_long,scm_from_long);
-    specialize_std_pair_on_second(long,scm_is_number,
-                                scm_to_long,scm_from_long);
-    specialize_std_pair_on_second(unsigned int,scm_is_number,
-                                scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_second(unsigned short,scm_is_number,
-                                scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_second(unsigned long,scm_is_number,
-                                scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_second(double,scm_is_number,
-                                scm_to_double,scm_from_double);
-    specialize_std_pair_on_second(float,scm_is_number,
-                                scm_to_double,scm_from_double);
-    specialize_std_pair_on_second(std::string,scm_is_string,
-                                SWIG_scm2string,SWIG_string2scm);
-
-    specialize_std_pair_on_both(bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm,
-                               bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm);
-    specialize_std_pair_on_both(bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm,
-                               int,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm,
-                               short,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm,
-                               long,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm,
-                               unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm,
-                               unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm,
-                               unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm,
-                               double,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_pair_on_both(bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm,
-                               float,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_pair_on_both(bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm,
-                               std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm);
-    specialize_std_pair_on_both(int,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm);
-    specialize_std_pair_on_both(int,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               int,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(int,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               short,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(int,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               long,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(int,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(int,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(int,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(int,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               double,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_pair_on_both(int,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               float,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_pair_on_both(int,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm);
-    specialize_std_pair_on_both(short,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm);
-    specialize_std_pair_on_both(short,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               int,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(short,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               short,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(short,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               long,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(short,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(short,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(short,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(short,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               double,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_pair_on_both(short,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               float,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_pair_on_both(short,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm);
-    specialize_std_pair_on_both(long,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm);
-    specialize_std_pair_on_both(long,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               int,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(long,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               short,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(long,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               long,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(long,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(long,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(long,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(long,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               double,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_pair_on_both(long,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               float,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_pair_on_both(long,scm_is_number,
-                               scm_to_long,scm_from_long,
-                               std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm);
-    specialize_std_pair_on_both(unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm);
-    specialize_std_pair_on_both(unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               int,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               short,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               long,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               double,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_pair_on_both(unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               float,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_pair_on_both(unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm);
-    specialize_std_pair_on_both(unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm);
-    specialize_std_pair_on_both(unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               int,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               short,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               long,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               double,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_pair_on_both(unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               float,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_pair_on_both(unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm);
-    specialize_std_pair_on_both(unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm);
-    specialize_std_pair_on_both(unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               int,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               short,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               long,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               double,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_pair_on_both(unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               float,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_pair_on_both(unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong,
-                               std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm);
-    specialize_std_pair_on_both(double,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm);
-    specialize_std_pair_on_both(double,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               int,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(double,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               short,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(double,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               long,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(double,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(double,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(double,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(double,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               double,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_pair_on_both(double,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               float,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_pair_on_both(double,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm);
-    specialize_std_pair_on_both(float,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm);
-    specialize_std_pair_on_both(float,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               int,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(float,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               short,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(float,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               long,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(float,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(float,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(float,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(float,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               double,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_pair_on_both(float,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               float,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_pair_on_both(float,scm_is_number,
-                               scm_to_double,scm_from_double,
-                               std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm);
-    specialize_std_pair_on_both(std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm,
-                               bool,scm_is_bool,
-                               scm_is_true,SWIG_bool2scm);
-    specialize_std_pair_on_both(std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm,
-                               int,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm,
-                               short,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm,
-                               long,scm_is_number,
-                               scm_to_long,scm_from_long);
-    specialize_std_pair_on_both(std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm,
-                               unsigned int,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm,
-                               unsigned short,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm,
-                               unsigned long,scm_is_number,
-                               scm_to_ulong,scm_from_ulong);
-    specialize_std_pair_on_both(std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm,
-                               double,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_pair_on_both(std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm,
-                               float,scm_is_number,
-                               scm_to_double,scm_from_double);
-    specialize_std_pair_on_both(std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm,
-                               std::string,scm_is_string,
-                               SWIG_scm2string,SWIG_string2scm);
-}
diff --git a/share/swig/2.0.11/guile/std_vector.i b/share/swig/2.0.11/guile/std_vector.i
deleted file mode 100644
index 79c716b..0000000
--- a/share/swig/2.0.11/guile/std_vector.i
+++ /dev/null
@@ -1,410 +0,0 @@
-/* -----------------------------------------------------------------------------
- * std_vector.i
- *
- * SWIG typemaps for std::vector
- * ----------------------------------------------------------------------------- */
-
-%include <std_common.i>
-
-// ------------------------------------------------------------------------
-// std::vector
-// 
-// The aim of all that follows would be to integrate std::vector with 
-// Guile as much as possible, namely, to allow the user to pass and 
-// be returned Guile vectors or lists.
-// const declarations are used to guess the intent of the function being
-// exported; therefore, the following rationale is applied:
-// 
-//   -- f(std::vector<T>), f(const std::vector<T>&), f(const std::vector<T>*):
-//      the parameter being read-only, either a Guile sequence or a
-//      previously wrapped std::vector<T> can be passed.
-//   -- f(std::vector<T>&), f(std::vector<T>*):
-//      the parameter must be modified; therefore, only a wrapped std::vector
-//      can be passed.
-//   -- std::vector<T> f():
-//      the vector is returned by copy; therefore, a Guile vector of T:s 
-//      is returned which is most easily used in other Guile functions
-//   -- std::vector<T>& f(), std::vector<T>* f(), const std::vector<T>& f(),
-//      const std::vector<T>* f():
-//      the vector is returned by reference; therefore, a wrapped std::vector
-//      is returned
-// ------------------------------------------------------------------------
-
-%{
-#include <vector>
-#include <algorithm>
-#include <stdexcept>
-%}
-
-// exported class
-
-namespace std {
-    
-    template<class T> class vector {
-        %typemap(in) vector<T> {
-            if (scm_is_vector($input)) {
-                unsigned long size = scm_c_vector_length($input);
-                $1 = std::vector<T >(size);
-                for (unsigned long i=0; i<size; i++) {
-                    SCM o = scm_vector_ref($input,scm_from_ulong(i));
-                    (($1_type &)$1)[i] =
-                        *((T*) SWIG_MustGetPtr(o,$descriptor(T *),$argnum, 0));
-                }
-            } else if (scm_is_null($input)) {
-                $1 = std::vector<T >();
-            } else if (scm_is_pair($input)) {
-                SCM head, tail;
-                $1 = std::vector<T >();
-                tail = $input;
-                while (!scm_is_null(tail)) {
-                    head = SCM_CAR(tail);
-                    tail = SCM_CDR(tail);
-                    $1.push_back(*((T*)SWIG_MustGetPtr(head,
-                                                       $descriptor(T *),
-                                                       $argnum, 0)));
-                }
-            } else {
-                $1 = *(($&1_type)
-                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
-            }
-        }
-        %typemap(in) const vector<T>& (std::vector<T> temp),
-                     const vector<T>* (std::vector<T> temp) {
-            if (scm_is_vector($input)) {
-                unsigned long size = scm_c_vector_length($input);
-                temp = std::vector<T >(size);
-                $1 = &temp;
-                for (unsigned long i=0; i<size; i++) {
-                    SCM o = scm_vector_ref($input,scm_from_ulong(i));
-                    temp[i] = *((T*) SWIG_MustGetPtr(o,
-                                                     $descriptor(T *),
-                                                     $argnum, 0));
-                }
-            } else if (scm_is_null($input)) {
-                temp = std::vector<T >();
-                $1 = &temp;
-            } else if (scm_is_pair($input)) {
-                temp = std::vector<T >();
-                $1 = &temp;
-                SCM head, tail;
-                tail = $input;
-                while (!scm_is_null(tail)) {
-                    head = SCM_CAR(tail);
-                    tail = SCM_CDR(tail);
-                    temp.push_back(*((T*) SWIG_MustGetPtr(head,
-                                                          $descriptor(T *),
-                                                          $argnum, 0)));
-                }
-            } else {
-                $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
-            }
-        }
-        %typemap(out) vector<T> {
-            $result = scm_make_vector(scm_from_long($1.size()),SCM_UNSPECIFIED);
-            for (unsigned int i=0; i<$1.size(); i++) {
-                T* x = new T((($1_type &)$1)[i]);
-                scm_vector_set_x($result,scm_from_long(i),
-                                SWIG_NewPointerObj(x, $descriptor(T *), 1));
-            }
-        }
-        %typecheck(SWIG_TYPECHECK_VECTOR) vector<T> {
-            /* native sequence? */
-            if (scm_is_vector($input)) {
-                unsigned int size = scm_c_vector_length($input);
-                if (size == 0) {
-                    /* an empty sequence can be of any type */
-                    $1 = 1;
-                } else {
-                    /* check the first element only */
-                    SCM o = scm_vector_ref($input,scm_from_ulong(0));
-                    T* x;
-                    if (SWIG_ConvertPtr(o,(void**) &x,
-                                          $descriptor(T *), 0) != -1)
-                        $1 = 1;
-                    else
-                        $1 = 0;
-                }
-            } else if (scm_is_null($input)) {
-                /* again, an empty sequence can be of any type */
-                $1 = 1;
-            } else if (scm_is_pair($input)) {
-                /* check the first element only */
-                T* x;
-                SCM head = SCM_CAR($input);
-                if (SWIG_ConvertPtr(head,(void**) &x,
-                                      $descriptor(T *), 0) != -1)
-                    $1 = 1;
-                else
-                    $1 = 0;
-            } else {
-                /* wrapped vector? */
-                std::vector<T >* v;
-                if (SWIG_ConvertPtr($input,(void **) &v, 
-                                      $&1_descriptor, 0) != -1)
-                    $1 = 1;
-                else
-                    $1 = 0;
-            }
-        }
-        %typecheck(SWIG_TYPECHECK_VECTOR) const vector<T>&,
-                                          const vector<T>* {
-            /* native sequence? */
-            if (scm_is_vector($input)) {
-                unsigned int size = scm_c_vector_length($input);
-                if (size == 0) {
-                    /* an empty sequence can be of any type */
-                    $1 = 1;
-                } else {
-                    /* check the first element only */
-                    T* x;
-                    SCM o = scm_vector_ref($input,scm_from_ulong(0));
-                    if (SWIG_ConvertPtr(o,(void**) &x,
-                                          $descriptor(T *), 0) != -1)
-                        $1 = 1;
-                    else
-                        $1 = 0;
-                }
-            } else if (scm_is_null($input)) {
-                /* again, an empty sequence can be of any type */
-                $1 = 1;
-            } else if (scm_is_pair($input)) {
-                /* check the first element only */
-                T* x;
-                SCM head = SCM_CAR($input);
-                if (SWIG_ConvertPtr(head,(void**) &x,
-                                      $descriptor(T *), 0) != -1)
-                    $1 = 1;
-                else
-                    $1 = 0;
-            } else {
-                /* wrapped vector? */
-                std::vector<T >* v;
-                if (SWIG_ConvertPtr($input,(void **) &v, 
-                                      $1_descriptor, 0) != -1)
-                    $1 = 1;
-                else
-                    $1 = 0;
-            }
-        }
-      public:
-        vector(unsigned int size = 0);
-        vector(unsigned int size, const T& value);
-        vector(const vector<T>&);
-        %rename(length) size;
-        unsigned int size() const;
-        %rename("empty?") empty;
-        bool empty() const;
-        %rename("clear!") clear;
-        void clear();
-        %rename("set!") set;
-        %rename("pop!") pop;
-        %rename("push!") push_back;
-        void push_back(const T& x);
-        %extend {
-            T pop() throw (std::out_of_range) {
-                if (self->size() == 0)
-                    throw std::out_of_range("pop from empty vector");
-                T x = self->back();
-                self->pop_back();
-                return x;
-            }
-            const T& ref(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 T& x) throw (std::out_of_range) {
-                int size = int(self->size());
-                if (i>=0 && i<size)
-                    (*self)[i] = x;
-                else
-                    throw std::out_of_range("vector index out of range");
-            }
-        }
-    };
-
-
-    // specializations for built-ins
-    %define specialize_stl_vector(T,CHECK,CONVERT_FROM,CONVERT_TO)
-    template<> class vector<T> {
-        %typemap(in) vector<T> {
-            if (scm_is_vector($input)) {
-                unsigned long size = scm_c_vector_length($input);
-                $1 = std::vector<T >(size);
-                for (unsigned long i=0; i<size; i++) {
-                    SCM o = scm_vector_ref($input,scm_from_ulong(i));
-                    if (CHECK(o))
-                        (($1_type &)$1)[i] = (T)(CONVERT_FROM(o));
-                    else
-                        scm_wrong_type_arg(FUNC_NAME, $argnum, $input);
-                }
-            } else if (scm_is_null($input)) {
-                $1 = std::vector<T >();
-            } else if (scm_is_pair($input)) {
-                SCM v = scm_vector($input);
-                unsigned long size = scm_c_vector_length(v);
-                $1 = std::vector<T >(size);
-                for (unsigned long i=0; i<size; i++) {
-                    SCM o = scm_vector_ref(v,scm_from_ulong(i));
-                    if (CHECK(o))
-                        (($1_type &)$1)[i] = (T)(CONVERT_FROM(o));
-                    else
-                        scm_wrong_type_arg(FUNC_NAME, $argnum, $input);
-                }
-            } else {
-                $1 = *(($&1_type)
-                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
-            }
-        }
-        %typemap(in) const vector<T>& (std::vector<T> temp),
-                     const vector<T>* (std::vector<T> temp) {
-            if (scm_is_vector($input)) {
-                unsigned long size = scm_c_vector_length($input);
-                temp = std::vector<T >(size);
-                $1 = &temp;
-                for (unsigned long i=0; i<size; i++) {
-                    SCM o = scm_vector_ref($input,scm_from_ulong(i));
-                    if (CHECK(o))
-                        temp[i] = (T)(CONVERT_FROM(o));
-                    else
-                        scm_wrong_type_arg(FUNC_NAME, $argnum, $input);
-                }
-            } else if (scm_is_null($input)) {
-                temp = std::vector<T >();
-                $1 = &temp;
-            } else if (scm_is_pair($input)) {
-                SCM v = scm_vector($input);
-                unsigned long size = scm_c_vector_length(v);
-                temp = std::vector<T >(size);
-                $1 = &temp;
-                for (unsigned long i=0; i<size; i++) {
-                    SCM o = scm_vector_ref(v,scm_from_ulong(i));
-                    if (CHECK(o))
-                        temp[i] = (T)(CONVERT_FROM(o));
-                    else
-                        scm_wrong_type_arg(FUNC_NAME, $argnum, $input);
-                }
-            } else {
-                $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
-            }
-        }
-        %typemap(out) vector<T> {
-            $result = scm_make_vector(scm_from_long($1.size()),SCM_UNSPECIFIED);
-            for (unsigned int i=0; i<$1.size(); i++) {
-                SCM x = CONVERT_TO((($1_type &)$1)[i]);
-                scm_vector_set_x($result,scm_from_long(i),x);
-            }
-        }
-        %typecheck(SWIG_TYPECHECK_VECTOR) vector<T> {
-            /* native sequence? */
-            if (scm_is_vector($input)) {
-                unsigned int size = scm_c_vector_length($input);
-                if (size == 0) {
-                    /* an empty sequence can be of any type */
-                    $1 = 1;
-                } else {
-                    /* check the first element only */
-                    T* x;
-                    SCM o = scm_vector_ref($input,scm_from_ulong(0));
-                    $1 = CHECK(o) ? 1 : 0;
-                }
-            } else if (scm_is_null($input)) {
-                /* again, an empty sequence can be of any type */
-                $1 = 1;
-            } else if (scm_is_pair($input)) {
-                /* check the first element only */
-                T* x;
-                SCM head = SCM_CAR($input);
-                $1 = CHECK(head) ? 1 : 0;
-            } else {
-                /* wrapped vector? */
-                std::vector<T >* v;
-                $1 = (SWIG_ConvertPtr($input,(void **) &v, 
-                                        $&1_descriptor, 0) != -1) ? 1 : 0;
-            }
-        }
-        %typecheck(SWIG_TYPECHECK_VECTOR) const vector<T>&,
-                                          const vector<T>* {
-            /* native sequence? */
-            if (scm_is_vector($input)) {
-                unsigned int size = scm_c_vector_length($input);
-                if (size == 0) {
-                    /* an empty sequence can be of any type */
-                    $1 = 1;
-                } else {
-                    /* check the first element only */
-                    T* x;
-                    SCM o = scm_vector_ref($input,scm_from_ulong(0));
-                    $1 = CHECK(o) ? 1 : 0;
-                }
-            } else if (scm_is_null($input)) {
-                /* again, an empty sequence can be of any type */
-                $1 = 1;
-            } else if (scm_is_pair($input)) {
-                /* check the first element only */
-                T* x;
-                SCM head = SCM_CAR($input);
-                $1 = CHECK(head) ? 1 : 0;
-            } else {
-                /* wrapped vector? */
-                std::vector<T >* v;
-                $1 = (SWIG_ConvertPtr($input,(void **) &v, 
-                                        $1_descriptor, 0) != -1) ? 1 : 0;
-            }
-        }
-      public:
-        vector(unsigned int size = 0);
-        vector(unsigned int size, const T& value);
-        vector(const vector<T>&);
-        %rename(length) size;
-        unsigned int size() const;
-        %rename("empty?") empty;
-        bool empty() const;
-        %rename("clear!") clear;
-        void clear();
-        %rename("set!") set;
-        %rename("pop!") pop;
-        %rename("push!") push_back;
-        void push_back(T x);
-        %extend {
-            T pop() throw (std::out_of_range) {
-                if (self->size() == 0)
-                    throw std::out_of_range("pop from empty vector");
-                T x = self->back();
-                self->pop_back();
-                return x;
-            }
-            T ref(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, T x) throw (std::out_of_range) {
-                int size = int(self->size());
-                if (i>=0 && i<size)
-                    (*self)[i] = x;
-                else
-                    throw std::out_of_range("vector index out of range");
-            }
-        }
-    };
-    %enddef
-
-    specialize_stl_vector(bool,scm_is_bool,scm_is_true,SWIG_bool2scm);
-    specialize_stl_vector(char,scm_is_number,scm_to_long,scm_from_long);
-    specialize_stl_vector(int,scm_is_number,scm_to_long,scm_from_long);
-    specialize_stl_vector(long,scm_is_number,scm_to_long,scm_from_long);
-    specialize_stl_vector(short,scm_is_number,scm_to_long,scm_from_long);
-    specialize_stl_vector(unsigned char,scm_is_number,scm_to_ulong,scm_from_ulong);
-    specialize_stl_vector(unsigned int,scm_is_number,scm_to_ulong,scm_from_ulong);
-    specialize_stl_vector(unsigned long,scm_is_number,scm_to_ulong,scm_from_ulong);
-    specialize_stl_vector(unsigned short,scm_is_number,scm_to_ulong,scm_from_ulong);
-    specialize_stl_vector(float,scm_is_number,scm_to_double,scm_from_double);
-    specialize_stl_vector(double,scm_is_number,scm_to_double,scm_from_double);
-    specialize_stl_vector(std::string,scm_is_string,SWIG_scm2string,SWIG_string2scm);
-}
-
diff --git a/share/swig/2.0.11/guile/typemaps.i b/share/swig/2.0.11/guile/typemaps.i
deleted file mode 100644
index ba447ac..0000000
--- a/share/swig/2.0.11/guile/typemaps.i
+++ /dev/null
@@ -1,457 +0,0 @@
-/* -----------------------------------------------------------------------------
- * typemaps.i
- *
- * Guile-specific typemaps
- * ----------------------------------------------------------------------------- */
-
-/* Pointers */
-
-%typemap(in) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
-  $1 = ($1_ltype)SWIG_MustGetPtr($input, $descriptor, $argnum, 0);
-}
-%typemap(freearg) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] "";
-
-%typemap(in) void * {
-  $1 = ($1_ltype)SWIG_MustGetPtr($input, NULL, $argnum, 0);
-}
-%typemap(freearg) void * "";
-
-%typemap(varin) SWIGTYPE * {
-  $1 = ($1_ltype)SWIG_MustGetPtr($input, $descriptor, 1, 0);
-}
-
-%typemap(varin) SWIGTYPE & {
-  $1 = *(($1_ltype)SWIG_MustGetPtr($input, $descriptor, 1, 0));
-}
-
-%typemap(varin) SWIGTYPE [] {
-  scm_wrong_type_arg((char *) FUNC_NAME, 1, $input);
-}
-
-%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 [] {
-  $result = SWIG_NewPointerObj ($1, $descriptor, $owner);
-}
-
-%typemap(out) SWIGTYPE *DYNAMIC, SWIGTYPE &DYNAMIC {
-  swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor,(void **) &$1);
-  $result = SWIG_NewPointerObj ($1, ty, $owner);
-}
-    
-%typemap(varout) SWIGTYPE *, SWIGTYPE [] {
-  $result = SWIG_NewPointerObj ($1, $descriptor, 0);
-}
-
-%typemap(varout) SWIGTYPE & {
-  $result = SWIG_NewPointerObj((void *) &$1, $1_descriptor, 0);
-}
-
-%typemap(throws) SWIGTYPE {
-  $&ltype temp = new $ltype($1);
-  scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
-	    scm_listify(SWIG_NewPointerObj(temp, $&descriptor, 1),
-		    SCM_UNDEFINED));
-}
-
-%typemap(throws) SWIGTYPE & {
-  scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
-	    scm_listify(SWIG_NewPointerObj(&$1, $descriptor, 1),
-		    SCM_UNDEFINED));
-}
-
-%typemap(throws) SWIGTYPE * {
-  scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
-	    scm_listify(SWIG_NewPointerObj($1, $descriptor, 1),
-		    SCM_UNDEFINED));
-}
-
-%typemap(throws) SWIGTYPE [] {
-  scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
-	    scm_listify(SWIG_NewPointerObj($1, $descriptor, 1),
-		    SCM_UNDEFINED));
-}
-
-/* Change of object ownership, and interaction of destructor-like functions and the
-   garbage-collector */
-
-%typemap(in, doc="$NAME is of type <$type> and gets destroyed by the function") SWIGTYPE *DESTROYED {
-  $1 = ($1_ltype)SWIG_MustGetPtr($input, $descriptor, $argnum, 0);
-}
-
-%typemap(freearg) SWIGTYPE *DESTROYED {
-  SWIG_Guile_MarkPointerDestroyed($input);
-}
-
-%typemap(in, doc="$NAME is of type <$type> and is consumed by the function") SWIGTYPE *CONSUMED {
-  $1 = ($1_ltype)SWIG_MustGetPtr($input, $descriptor, $argnum, 0);
-  SWIG_Guile_MarkPointerNoncollectable($input);
-}
-
-/* Pass-by-value */
-
-%typemap(in) SWIGTYPE($&1_ltype argp) {
-  argp = ($&1_ltype)SWIG_MustGetPtr($input, $&1_descriptor, $argnum, 0);
-  $1 = *argp;
-}
-
-%typemap(varin) SWIGTYPE {
-  $&1_ltype argp;
-  argp = ($&1_ltype)SWIG_MustGetPtr($input, $&1_descriptor, 1, 0);
-  $1 = *argp;
-}
-
-%typemap(out) SWIGTYPE 
-#ifdef __cplusplus
-{
-  $&1_ltype resultptr;
-  resultptr = new $1_ltype((const $1_ltype &) $1);
-  $result =  SWIG_NewPointerObj (resultptr, $&1_descriptor, 1);
-} 
-#else
-{
-  $&1_ltype resultptr;
-  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;
-  resultptr = new $1_ltype((const $1_ltype&) $1);
-  $result =  SWIG_NewPointerObj (resultptr, $&1_descriptor, 0);
-} 
-#else
-{
-  $&1_ltype resultptr;
-  resultptr = ($&1_ltype) malloc(sizeof($1_type));
-  memmove(resultptr, &$1, sizeof($1_type));
-  $result = SWIG_NewPointerObj(resultptr, $&1_descriptor, 0);
-}
-#endif
-
-/* Enums */
-
-%typemap(in)     enum SWIGTYPE  { $1 = ($1_type) scm_to_int($input); }
-/* The complicated construction below needed to deal with anonymous
-   enums, which cannot be cast to. */
-%typemap(varin)  enum SWIGTYPE  {
-  if (sizeof(int) != sizeof($1)) {
-    scm_error(scm_from_locale_symbol("swig-error"),
-	      (char *) FUNC_NAME,
-	      (char *) "enum variable '$name' cannot be set",
-	      SCM_EOL, SCM_BOOL_F); 
-  }
-  * (int *) &($1) = scm_to_int($input);
-}
-%typemap(out)    enum SWIGTYPE  { $result = scm_from_long($1); }
-%typemap(varout) enum SWIGTYPE  { $result = scm_from_long($1); }
-%typemap(throws) enum SWIGTYPE {
-  scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
-     scm_listify(scm_from_long($1), SCM_UNDEFINED));
-}
-
-/* The SIMPLE_MAP_WITH_EXPR macro below defines the whole set of
-   typemaps needed for simple types.
-   -- SCM_TO_C_EXPR is a C expression that translates the Scheme value
-      "swig_scm_value" to a C value.
-   -- C_TO_SCM_EXPR is a C expression that translates the C value
-      "swig_c_value" to a Scheme value. */
-
-%define SIMPLE_MAP_WITH_EXPR(C_NAME, SCM_TO_C_EXPR, C_TO_SCM_EXPR, SCM_NAME)
- %typemap (in,     doc="$NAME is of type <" #SCM_NAME ">") C_NAME
-     { SCM swig_scm_value = $input;
-       $1 = SCM_TO_C_EXPR; }
- %typemap (varin,  doc="NEW-VALUE is of type <" #SCM_NAME ">") C_NAME
-     { SCM swig_scm_value = $input;
-       $1 = SCM_TO_C_EXPR; }
- %typemap (out,    doc="<" #SCM_NAME ">") C_NAME
-     { C_NAME swig_c_value = $1;
-       $result = C_TO_SCM_EXPR; }
- %typemap (varout, doc="<" #SCM_NAME ">") C_NAME
-     { C_NAME swig_c_value = $1;
-       $result = C_TO_SCM_EXPR; }
- /* INPUT and OUTPUT */
- %typemap (in, doc="$NAME is of type <" #SCM_NAME ">)")
-     C_NAME *INPUT(C_NAME temp) {
-       SCM swig_scm_value = $input;
-       temp = (C_NAME) SCM_TO_C_EXPR; $1 = &temp; }
- %typemap (in,numinputs=0)      C_NAME *OUTPUT (C_NAME temp)
-     {$1 = &temp;}
- %typemap (argout,doc="$name (of type <" #SCM_NAME ">)") C_NAME *OUTPUT
-     { C_NAME swig_c_value = *$1;
-       SWIG_APPEND_VALUE(C_TO_SCM_EXPR); }
- %typemap (in)          C_NAME *BOTH = C_NAME *INPUT;
- %typemap (argout)      C_NAME *BOTH = C_NAME *OUTPUT;
- %typemap (in)          C_NAME *INOUT = C_NAME *INPUT;
- %typemap (argout)      C_NAME *INOUT = C_NAME *OUTPUT;
- /* Const primitive references.  Passed by value */
- %typemap(in, doc="$NAME is of type <" #SCM_NAME ">") const C_NAME & (C_NAME temp)
-     { SCM swig_scm_value = $input;
-       temp = SCM_TO_C_EXPR;
-       $1 = &temp; }
- %typemap(out, doc="<" #SCM_NAME ">")  const C_NAME &
-     { C_NAME swig_c_value = *$1;
-       $result = C_TO_SCM_EXPR; }
- /* Throw typemap */
- %typemap(throws) C_NAME {
-   C_NAME swig_c_value = $1;
-   scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
-	     scm_listify(C_TO_SCM_EXPR, SCM_UNDEFINED));
- }
-%enddef
-
-/* The SIMPLE_MAP macro below defines the whole set of typemaps needed
-   for simple types.  It generates slightly simpler code than the
-   macro above, but it is only suitable for very simple conversion
-   expressions. */
-
-%define SIMPLE_MAP(C_NAME, SCM_TO_C, C_TO_SCM, SCM_NAME)
- %typemap (in,     doc="$NAME is of type <" #SCM_NAME ">")
-     C_NAME {$1 = ($1_ltype) SCM_TO_C($input);}
- %typemap (varin,  doc="NEW-VALUE is of type <" #SCM_NAME ">")
-     C_NAME {$1 = ($1_ltype) SCM_TO_C($input);}
- %typemap (out,    doc="<" #SCM_NAME ">")
-     C_NAME {$result = C_TO_SCM($1);}
- %typemap (varout, doc="<" #SCM_NAME ">")
-     C_NAME {$result = C_TO_SCM($1);}
- /* INPUT and OUTPUT */
- %typemap (in, doc="$NAME is of type <" #SCM_NAME ">)")
-     C_NAME *INPUT(C_NAME temp), C_NAME &INPUT(C_NAME temp) {
-   temp = (C_NAME) SCM_TO_C($input); $1 = &temp;
- }
- %typemap (in,numinputs=0)      C_NAME *OUTPUT (C_NAME temp), C_NAME &OUTPUT(C_NAME temp)
-   {$1 = &temp;}
- %typemap (argout,doc="$name (of type <" #SCM_NAME ">)") C_NAME *OUTPUT, C_NAME &OUTPUT
-   {SWIG_APPEND_VALUE(C_TO_SCM(*$1));}
- %typemap (in)          C_NAME *BOTH = C_NAME *INPUT;
- %typemap (argout)      C_NAME *BOTH = C_NAME *OUTPUT;
- %typemap (in)          C_NAME *INOUT = C_NAME *INPUT;
- %typemap (argout)      C_NAME *INOUT = C_NAME *OUTPUT;
- %typemap (in)          C_NAME &INOUT = C_NAME &INPUT;
- %typemap (argout)      C_NAME &INOUT = C_NAME &OUTPUT;
- /* Const primitive references.  Passed by value */
- %typemap(in, doc="$NAME is of type <" #SCM_NAME ">") const C_NAME & (C_NAME temp) {
-   temp = SCM_TO_C($input);
-   $1 = ($1_ltype) &temp;
- }
- %typemap(out, doc="<" #SCM_NAME ">")  const C_NAME & {
-   $result = C_TO_SCM(*$1);
- }
- /* Throw typemap */
- %typemap(throws) C_NAME {
-   scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
-	     scm_listify(C_TO_SCM($1), SCM_UNDEFINED));
- }
-%enddef
-
- SIMPLE_MAP(bool, scm_is_true, scm_from_bool, boolean);
- SIMPLE_MAP(char, SCM_CHAR, SCM_MAKE_CHAR, char);
- SIMPLE_MAP(unsigned char, SCM_CHAR, SCM_MAKE_CHAR, char);
- SIMPLE_MAP(signed char, SCM_CHAR, SCM_MAKE_CHAR, char);
- SIMPLE_MAP(int, scm_to_int, scm_from_long, integer);
- SIMPLE_MAP(short, scm_to_short, scm_from_long, integer);
- SIMPLE_MAP(long, scm_to_long, scm_from_long, integer);
- SIMPLE_MAP(ptrdiff_t, scm_to_long, scm_from_long, integer);
- SIMPLE_MAP(unsigned int, scm_to_uint, scm_from_ulong, integer);
- SIMPLE_MAP(unsigned short, scm_to_ushort, scm_from_ulong, integer);
- SIMPLE_MAP(unsigned long, scm_to_ulong, scm_from_ulong, integer);
- SIMPLE_MAP(size_t, scm_to_ulong, scm_from_ulong, integer);
- SIMPLE_MAP(float, scm_to_double, scm_from_double, real);
- SIMPLE_MAP(double, scm_to_double, scm_from_double, real);
-// SIMPLE_MAP(char *, SWIG_scm2str, SWIG_str02scm, string);
-// SIMPLE_MAP(const char *, SWIG_scm2str, SWIG_str02scm, string);
-
-/* Define long long typemaps -- uses functions that are only defined
-   in recent versions of Guile, availability also depends on Guile's
-   configuration. */
-
-SIMPLE_MAP(long long, scm_to_long_long, scm_from_long_long, integer);
-SIMPLE_MAP(unsigned long long, scm_to_ulong_long, scm_from_ulong_long, integer);
-
-/* Strings */
-
- %typemap (in,     doc="$NAME is a string")      char *(int must_free = 0) {
-  $1 = ($1_ltype)SWIG_scm2str($input);
-  must_free = 1;
- }
- %typemap (varin,  doc="NEW-VALUE is a string")  char * {$1 = ($1_ltype)SWIG_scm2str($input);}
- %typemap (out,    doc="<string>")              char * {$result = SWIG_str02scm((const char *)$1);}
- %typemap (varout, doc="<string>")              char * {$result = SWIG_str02scm($1);}
- %typemap (in, doc="$NAME is a string")          char **INPUT(char * temp, int must_free = 0) {
-   temp = (char *) SWIG_scm2str($input); $1 = &temp;
-   must_free = 1;
- }
- %typemap (in,numinputs=0)  char **OUTPUT (char * temp)
-   {$1 = &temp;}
- %typemap (argout,doc="$NAME (a string)") char **OUTPUT
-   {SWIG_APPEND_VALUE(SWIG_str02scm(*$1));}
- %typemap (in)          char **BOTH = char **INPUT;
- %typemap (argout)      char **BOTH = char **OUTPUT;
- %typemap (in)          char **INOUT = char **INPUT;
- %typemap (argout)      char **INOUT = char **OUTPUT;
-
-/* SWIG_scm2str makes a malloc'ed copy of the string, so get rid of it after
-   the function call. */
-
-%typemap (freearg) char * "if (must_free$argnum && $1) SWIG_free($1);";
-%typemap (freearg) char **INPUT, char **BOTH "if (must_free$argnum && (*$1)) SWIG_free(*$1);"
-%typemap (freearg) char **OUTPUT "SWIG_free(*$1);"
-  
-/* But this shall not apply if we try to pass a single char by
-   reference. */
-
-%typemap (freearg) char *OUTPUT, char *BOTH "";
-
-/* If we set a string variable, delete the old result first, unless const. */
-
-%typemap (varin) char * {
-    if ($1) free($1);
-    $1 = ($1_ltype) SWIG_scm2str($input);
-}
-
-%typemap (varin) const char * {
-    $1 = ($1_ltype) SWIG_scm2str($input);
-}
-
-%typemap(throws) char * {
-  scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
-	    scm_listify(SWIG_str02scm($1), SCM_UNDEFINED));
-}
-
-/* Void */
-
-%typemap (out,doc="") void "gswig_result = SCM_UNSPECIFIED;";
-
-/* SCM is passed through */
-
-typedef unsigned long SCM;
-%typemap (in) SCM "$1=$input;";
-%typemap (out) SCM "$result=$1;";
-%typecheck(SWIG_TYPECHECK_POINTER) SCM "$1=1;";
-
-/* ------------------------------------------------------------
- * String & length
- * ------------------------------------------------------------ */
-
-%typemap(in) (char *STRING, int LENGTH), (char *STRING, size_t LENGTH) {
-    size_t temp;
-    $1 = ($1_ltype) SWIG_Guile_scm2newstr($input, &temp);
-    $2 = ($2_ltype) temp;
-}
-
-/* ------------------------------------------------------------
- * CLASS::* (member function pointer) typemaps
- * taken from typemaps/swigtype.swg
- * ------------------------------------------------------------ */
-
-#define %set_output(obj)                  $result = obj
-#define %set_varoutput(obj)               $result = obj
-#define %argument_fail(code, type, name, argn)	scm_wrong_type_arg((char *) FUNC_NAME, argn, $input);
-#define %as_voidptr(ptr)		(void*)(ptr)
-
-%typemap(in) SWIGTYPE (CLASS::*) {  
-  int res = SWIG_ConvertMember($input, %as_voidptr(&$1), sizeof($type),$descriptor);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res,"$type",$symname, $argnum); 
-  }
-}
-
-%typemap(out,noblock=1) SWIGTYPE (CLASS::*) {
-  %set_output(SWIG_NewMemberObj(%as_voidptr(&$1), sizeof($type), $descriptor));
-}
-
-%typemap(varin) SWIGTYPE (CLASS::*) {
-  int res = SWIG_ConvertMember($input,%as_voidptr(&$1), sizeof($type), $descriptor);
-  if (!SWIG_IsOK(res)) {
-    scm_wrong_type_arg((char *) FUNC_NAME, 1, $input);
-  }
-}
-
-%typemap(varout,noblock=1) SWIGTYPE (CLASS::*) {
-  %set_varoutput(SWIG_NewMemberObj(%as_voidptr(&$1), sizeof($type), $descriptor));
-}
-
-/* ------------------------------------------------------------
- * Typechecking rules
- * ------------------------------------------------------------ */
-
-/* adapted from python.swg */
-
-%typecheck(SWIG_TYPECHECK_INTEGER)
-	 int, short, long,
- 	 unsigned int, unsigned short, unsigned long,
-	 signed char, unsigned char,
-	 long long, unsigned long long,
-         size_t, ptrdiff_t,
-         std::size_t, std::ptrdiff_t,
-	 const int &, const short &, const long &,
- 	 const unsigned int &, const unsigned short &, const unsigned long &,
-	 const long long &, const unsigned long long &,
-         const size_t &, const ptrdiff_t &,
-         const std::size_t &, const std::ptrdiff_t &,
-	 enum SWIGTYPE
-{
-  $1 = scm_is_true(scm_integer_p($input)) && scm_is_true(scm_exact_p($input))? 1 : 0;
-}
-
-%typecheck(SWIG_TYPECHECK_BOOL)
-	bool, bool&, const bool&
-{
-  $1 = SCM_BOOLP($input) ? 1 : 0;
-}
-
-%typecheck(SWIG_TYPECHECK_DOUBLE)
-	float, double,
-	const float &, const double &
-{
-  $1 = scm_is_true(scm_real_p($input)) ? 1 : 0;
-}
-
-%typecheck(SWIG_TYPECHECK_CHAR) char {
-  $1 = SCM_CHARP($input) ? 1 : 0;
-}
-
-%typecheck(SWIG_TYPECHECK_STRING) char * {
-  $1 = scm_is_string($input) ? 1 : 0;
-}
-
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
-  void *ptr;
-  int res = SWIG_ConvertPtr($input, &ptr, $1_descriptor, 0);
-  $1 = SWIG_CheckState(res);
-}
-
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE {
-  void *ptr;
-  int res = SWIG_ConvertPtr($input, &ptr, $&descriptor, 0);
-  $1 = SWIG_CheckState(res);
-}
-
-%typecheck(SWIG_TYPECHECK_VOIDPTR) void * {
-  void *ptr;
-  int res = SWIG_ConvertPtr($input, &ptr, 0, 0);
-  $1 = SWIG_CheckState(res);
-}
-
-/* Array reference typemaps */
-%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
-
-/* const pointers */
-%apply SWIGTYPE * { SWIGTYPE *const }
-
-/* typemaps.i ends here */
diff --git a/share/swig/2.0.11/inttypes.i b/share/swig/2.0.11/inttypes.i
deleted file mode 100644
index 8450cb8..0000000
--- a/share/swig/2.0.11/inttypes.i
+++ /dev/null
@@ -1,91 +0,0 @@
-/* -----------------------------------------------------------------------------
- * inttypes.i
- *
- * SWIG library file  for ISO C99 types: 7.8 Format conversion of integer types <inttypes.h>
- * ----------------------------------------------------------------------------- */
-
-%{
-#include <inttypes.h>
-%}
-
-%include <stdint.i>
-%include <wchar.i>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef SWIGWORDSIZE64
-  
-  /* We have to define the `uintmax_t' type using `ldiv_t'.  */
-  typedef struct
-  {
-    long int quot;		/* Quotient.  */
-    long int rem;		/* Remainder.  */
-  } imaxdiv_t;
-  
-#else
-  
-  /* We have to define the `uintmax_t' type using `lldiv_t'.  */
-  typedef struct
-  {
-    long long int quot;		/* Quotient.  */
-    long long int rem;		/* Remainder.  */
-  } imaxdiv_t;
-
-#endif
-
-  /* Compute absolute value of N.  */
-  extern intmax_t imaxabs (intmax_t n);
-
-  /* Return the `imaxdiv_t' representation of the value of NUMER over DENOM. */
-  extern imaxdiv_t imaxdiv (intmax_t numer, intmax_t denom);
-  
-  /* Like `strtol' but convert to `intmax_t'.  */
-  extern intmax_t strtoimax (const char *nptr, char **endptr, int base);
-  
-  /* Like `strtoul' but convert to `uintmax_t'.  */
-  extern uintmax_t strtoumax (const char *nptr, char ** endptr, int base);
-
-#ifdef SWIG_WCHAR
-  /* Like `wcstol' but convert to `intmax_t'.  */
-  extern intmax_t wcstoimax (const wchar_t *nptr, wchar_t **endptr, int base);
-  
-  /* Like `wcstoul' but convert to `uintmax_t'.  */
-  extern uintmax_t wcstoumax (const wchar_t *nptr, wchar_t ** endptr, int base);
-#endif
-
-#ifdef SWIGWORDSIZE64
-  
-  /* Like `strtol' but convert to `intmax_t'.  */
-  extern  intmax_t strtoimax (const char *nptr, char **endptr, int base);
-  
-  /* Like `strtoul' but convert to `uintmax_t'.  */
-  extern  uintmax_t strtoumax (const char *nptr, char **endptr,int base);
-  
-#ifdef SWIG_WCHAR
-  /* Like `wcstol' but convert to `intmax_t'.  */
-  extern  intmax_t wcstoimax (const wchar_t *nptr, wchar_t **endptr, int base);
-  
-  /* Like `wcstoul' but convert to `uintmax_t'.  */
-  extern  uintmax_t wcstoumax (const wchar_t *nptr, wchar_t **endptr, int base);
-#endif
-  
-#else /* SWIGWORDSIZE32 */
-  
-  /* Like `strtol' but convert to `intmax_t'.  */
-  extern  intmax_t strtoimax (const char *nptr, char **endptr, int base);
-  
-  /* Like `strtoul' but convert to `uintmax_t'.  */
-  extern  uintmax_t strtoumax (const char *nptr, char **endptr, int base);
-  
-#ifdef SWIG_WCHAR
-  /* Like `wcstol' but convert to `intmax_t'.  */
-  extern  uintmax_t wcstoumax (const wchar_t *nptr, wchar_t **endptr, int base);
-#endif
-
-#endif	/* SWIGWORDSIZE32 */
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/share/swig/2.0.11/java/arrays_java.i b/share/swig/2.0.11/java/arrays_java.i
deleted file mode 100644
index 4b780ae..0000000
--- a/share/swig/2.0.11/java/arrays_java.i
+++ /dev/null
@@ -1,390 +0,0 @@
-/* -----------------------------------------------------------------------------
- * arrays_java.i
- *
- * These typemaps give more natural support for arrays. The typemaps are not efficient
- * as there is a lot of copying of the array values whenever the array is passed to C/C++ 
- * from Java and vice versa. The Java array is expected to be the same size as the C array.
- * An exception is thrown if they are not.
- *
- * Example usage:
- * Wrapping:
- *
- *   %include <arrays_java.i>
- *   %inline %{
- *       short FiddleSticks[3];
- *   %}
- *
- * Use from Java like this:
- *
- *   short[] fs = new short[] {10, 11, 12};
- *   example.setFiddleSticks(fs);
- *   fs = example.getFiddleSticks();
- * ----------------------------------------------------------------------------- */
-
-/* Primitive array support is a combination of SWIG macros and functions in order to reduce 
- * code bloat and aid maintainability. The SWIG preprocessor expands the macros into functions 
- * for inclusion in the generated code. */
-
-/* Array support functions declarations macro */
-%define JAVA_ARRAYS_DECL(CTYPE, JNITYPE, JAVATYPE, JFUNCNAME)
-%{
-static int SWIG_JavaArrayIn##JFUNCNAME (JNIEnv *jenv, JNITYPE **jarr, CTYPE **carr, JNITYPE##Array input);
-static void SWIG_JavaArrayArgout##JFUNCNAME (JNIEnv *jenv, JNITYPE *jarr, CTYPE *carr, JNITYPE##Array input);
-static JNITYPE##Array SWIG_JavaArrayOut##JFUNCNAME (JNIEnv *jenv, CTYPE *result, jsize sz);
-%}
-%enddef
-
-/* Array support functions macro */
-%define JAVA_ARRAYS_IMPL(CTYPE, JNITYPE, JAVATYPE, JFUNCNAME)
-%{
-/* CTYPE[] support */
-static int SWIG_JavaArrayIn##JFUNCNAME (JNIEnv *jenv, JNITYPE **jarr, CTYPE **carr, JNITYPE##Array input) {
-  int i;
-  jsize sz;
-  if (!input) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
-    return 0;
-  }
-  sz = JCALL1(GetArrayLength, jenv, input);
-  *jarr = JCALL2(Get##JAVATYPE##ArrayElements, jenv, input, 0);
-  if (!*jarr)
-    return 0; %}
-#ifdef __cplusplus
-%{  *carr = new CTYPE[sz]; %}
-#else
-%{  *carr = (CTYPE*) calloc(sz, sizeof(CTYPE)); %}
-#endif
-%{  if (!*carr) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
-    return 0;
-  }
-  for (i=0; i<sz; i++)
-    JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN(CTYPE)
-  return 1;
-}
-
-static void SWIG_JavaArrayArgout##JFUNCNAME (JNIEnv *jenv, JNITYPE *jarr, CTYPE *carr, JNITYPE##Array input) {
-  int i;
-  jsize sz = JCALL1(GetArrayLength, jenv, input);
-  for (i=0; i<sz; i++)
-    jarr[i] = (JNITYPE)carr[i];
-  JCALL3(Release##JAVATYPE##ArrayElements, jenv, input, jarr, 0);
-}
-
-static JNITYPE##Array SWIG_JavaArrayOut##JFUNCNAME (JNIEnv *jenv, CTYPE *result, jsize sz) {
-  JNITYPE *arr;
-  int i;
-  JNITYPE##Array jresult = JCALL1(New##JAVATYPE##Array, jenv, sz);
-  if (!jresult)
-    return NULL;
-  arr = JCALL2(Get##JAVATYPE##ArrayElements, jenv, jresult, 0);
-  if (!arr)
-    return NULL;
-  for (i=0; i<sz; i++)
-    arr[i] = (JNITYPE)result[i];
-  JCALL3(Release##JAVATYPE##ArrayElements, jenv, jresult, arr, 0);
-  return jresult;
-}
-%}
-%enddef
-
-%{
-#if defined(SWIG_NOINCLUDE) || defined(SWIG_NOARRAYS)
-%}
-
-#ifdef __cplusplus
-JAVA_ARRAYS_DECL(bool, jboolean, Boolean, Bool)       /* bool[] */
-#endif
-
-JAVA_ARRAYS_DECL(signed char, jbyte, Byte, Schar)     /* signed char[] */
-JAVA_ARRAYS_DECL(unsigned char, jshort, Short, Uchar) /* unsigned char[] */
-JAVA_ARRAYS_DECL(short, jshort, Short, Short)         /* short[] */
-JAVA_ARRAYS_DECL(unsigned short, jint, Int, Ushort)   /* unsigned short[] */
-JAVA_ARRAYS_DECL(int, jint, Int, Int)                 /* int[] */
-JAVA_ARRAYS_DECL(unsigned int, jlong, Long, Uint)     /* unsigned int[] */
-JAVA_ARRAYS_DECL(long, jint, Int, Long)               /* long[] */
-JAVA_ARRAYS_DECL(unsigned long, jlong, Long, Ulong)   /* unsigned long[] */
-JAVA_ARRAYS_DECL(jlong, jlong, Long, Longlong)        /* long long[] */
-JAVA_ARRAYS_DECL(float, jfloat, Float, Float)         /* float[] */
-JAVA_ARRAYS_DECL(double, jdouble, Double, Double)     /* double[] */
-
-%{
-#else
-%}
-
-#ifdef __cplusplus
-/* Bool array element assignment different to other types to keep Visual C++ quiet */
-#define JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN(CTYPE) (*carr)[i] = ((*jarr)[i] != 0);
-JAVA_ARRAYS_IMPL(bool, jboolean, Boolean, Bool)       /* bool[] */
-#undef JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN
-#endif
-
-#define JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN(CTYPE) (*carr)[i] = (CTYPE)(*jarr)[i];
-JAVA_ARRAYS_IMPL(signed char, jbyte, Byte, Schar)     /* signed char[] */
-JAVA_ARRAYS_IMPL(unsigned char, jshort, Short, Uchar) /* unsigned char[] */
-JAVA_ARRAYS_IMPL(short, jshort, Short, Short)         /* short[] */
-JAVA_ARRAYS_IMPL(unsigned short, jint, Int, Ushort)   /* unsigned short[] */
-JAVA_ARRAYS_IMPL(int, jint, Int, Int)                 /* int[] */
-JAVA_ARRAYS_IMPL(unsigned int, jlong, Long, Uint)     /* unsigned int[] */
-JAVA_ARRAYS_IMPL(long, jint, Int, Long)               /* long[] */
-JAVA_ARRAYS_IMPL(unsigned long, jlong, Long, Ulong)   /* unsigned long[] */
-JAVA_ARRAYS_IMPL(jlong, jlong, Long, Longlong)        /* long long[] */
-JAVA_ARRAYS_IMPL(float, jfloat, Float, Float)         /* float[] */
-JAVA_ARRAYS_IMPL(double, jdouble, Double, Double)     /* double[] */
-
-%{
-#endif
-%}
-
-
-/* The rest of this file has the array typemaps */
-
-/* Arrays of primitive types use the following macro. The array typemaps use support functions. */
-%define JAVA_ARRAYS_TYPEMAPS(CTYPE, JTYPE, JNITYPE, JFUNCNAME, JNIDESC)
-
-%typemap(jni) CTYPE[ANY], CTYPE[]               %{JNITYPE##Array%}
-%typemap(jtype) CTYPE[ANY], CTYPE[]             %{JTYPE[]%}
-%typemap(jstype) CTYPE[ANY], CTYPE[]            %{JTYPE[]%}
-
-%typemap(in) CTYPE[] (JNITYPE *jarr)
-%{  if (!SWIG_JavaArrayIn##JFUNCNAME(jenv, &jarr, (CTYPE **)&$1, $input)) return $null; %}
-%typemap(in) CTYPE[ANY] (JNITYPE *jarr)
-%{  if ($input && JCALL1(GetArrayLength, jenv, $input) != $1_size) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
-    return $null;
-  }
-  if (!SWIG_JavaArrayIn##JFUNCNAME(jenv, &jarr, (CTYPE **)&$1, $input)) return $null; %}
-%typemap(argout) CTYPE[ANY], CTYPE[] 
-%{ SWIG_JavaArrayArgout##JFUNCNAME(jenv, jarr$argnum, (CTYPE *)$1, $input); %}
-%typemap(out) CTYPE[ANY]
-%{$result = SWIG_JavaArrayOut##JFUNCNAME(jenv, (CTYPE *)$1, $1_dim0); %}
-%typemap(out) CTYPE[] 
-%{$result = SWIG_JavaArrayOut##JFUNCNAME(jenv, (CTYPE *)$1, FillMeInAsSizeCannotBeDeterminedAutomatically); %}
-%typemap(freearg) CTYPE[ANY], CTYPE[] 
-#ifdef __cplusplus
-%{ delete [] $1; %}
-#else
-%{ free($1); %}
-#endif
-
-%typemap(javain) CTYPE[ANY], CTYPE[] "$javainput"
-%typemap(javaout) CTYPE[ANY], CTYPE[] {
-    return $jnicall;
-  }
-
-%typemap(memberin) CTYPE[ANY], CTYPE[];
-%typemap(globalin) CTYPE[ANY], CTYPE[];
-%enddef
-
-JAVA_ARRAYS_TYPEMAPS(bool, boolean, jboolean, Bool, "[Z")       /* bool[ANY] */
-JAVA_ARRAYS_TYPEMAPS(signed char, byte, jbyte, Schar, "[B")     /* signed char[ANY] */
-JAVA_ARRAYS_TYPEMAPS(unsigned char, short, jshort, Uchar, "[S") /* unsigned char[ANY] */
-JAVA_ARRAYS_TYPEMAPS(short, short, jshort, Short, "[S")         /* short[ANY] */
-JAVA_ARRAYS_TYPEMAPS(unsigned short, int, jint, Ushort, "[I")   /* unsigned short[ANY] */
-JAVA_ARRAYS_TYPEMAPS(int, int, jint, Int, "[I")                 /* int[ANY] */
-JAVA_ARRAYS_TYPEMAPS(unsigned int, long, jlong, Uint, "[J")     /* unsigned int[ANY] */
-JAVA_ARRAYS_TYPEMAPS(long, int, jint, Long, "[I")               /* long[ANY] */
-JAVA_ARRAYS_TYPEMAPS(unsigned long, long, jlong, Ulong, "[J")   /* unsigned long[ANY] */
-JAVA_ARRAYS_TYPEMAPS(long long, long, jlong, Longlong, "[J")    /* long long[ANY] */
-JAVA_ARRAYS_TYPEMAPS(float, float, jfloat, Float, "[F")         /* float[ANY] */
-JAVA_ARRAYS_TYPEMAPS(double, double, jdouble, Double, "[D")     /* double[ANY] */
-
-
-%typecheck(SWIG_TYPECHECK_BOOL_ARRAY) /* Java boolean[] */
-    bool[ANY], bool[]
-    ""
-
-%typecheck(SWIG_TYPECHECK_INT8_ARRAY) /* Java byte[] */
-    signed char[ANY], signed char[]
-    ""
-
-%typecheck(SWIG_TYPECHECK_INT16_ARRAY) /* Java short[] */
-    unsigned char[ANY], unsigned char[],
-    short[ANY], short[]
-    ""
-
-%typecheck(SWIG_TYPECHECK_INT32_ARRAY) /* Java int[] */
-    unsigned short[ANY], unsigned short[],
-    int[ANY], int[],
-    long[ANY], long[]
-    ""
-
-%typecheck(SWIG_TYPECHECK_INT64_ARRAY) /* Java long[] */
-    unsigned int[ANY], unsigned int[],
-    unsigned long[ANY], unsigned long[],
-    long long[ANY], long long[]
-    ""
-
-%typecheck(SWIG_TYPECHECK_INT128_ARRAY) /* Java BigInteger[] */
-    unsigned long long[ANY], unsigned long long[]
-    ""
-
-%typecheck(SWIG_TYPECHECK_FLOAT_ARRAY) /* Java float[] */
-    float[ANY], float[]
-    ""
-
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY) /* Java double[] */
-    double[ANY], double[]
-    ""
-
-
-/* Arrays of proxy classes. The typemaps in this macro make it possible to treat an array of 
- * class/struct/unions as an array of Java classes. 
- * Use the following macro to use these typemaps for an array of class/struct/unions called name:
- * JAVA_ARRAYSOFCLASSES(name) 
- * Note that multiple copies of the class/struct is made when using the array as a parameter input. */
-%define JAVA_ARRAYSOFCLASSES(ARRAYSOFCLASSES)
-
-%typemap(jni) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[] "jlongArray"
-%typemap(jtype) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[] "long[]"
-%typemap(jstype) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[] "$javaclassname[]"
-
-%typemap(javain) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[] "$javaclassname.cArrayUnwrap($javainput)"
-%typemap(javaout) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[] {
-    return $javaclassname.cArrayWrap($jnicall, $owner);
-  }
-
-%typemap(in) ARRAYSOFCLASSES[] (jlong *jarr, jsize sz)
-{
-  int i;
-  if (!$input) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
-    return $null;
-  }
-  sz = JCALL1(GetArrayLength, jenv, $input);
-  jarr = JCALL2(GetLongArrayElements, jenv, $input, 0);
-  if (!jarr) {
-    return $null;
-  }
-#ifdef __cplusplus
-  $1 = new $*1_ltype[sz];
-#else
-  $1 = ($1_ltype) calloc(sz, sizeof($*1_ltype));
-#endif
-  if (!$1) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
-    return $null;
-  }
-  for (i=0; i<sz; i++) {
-    $1[i] = **($&1_ltype)&jarr[i];
-  }
-}
-
-%typemap(in) ARRAYSOFCLASSES[ANY] (jlong *jarr, jsize sz)
-{
-  int i;
-  if (!$input) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
-    return $null;
-  }
-  sz = JCALL1(GetArrayLength, jenv, $input);
-  if (sz != $1_size) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
-    return $null;
-  }
-  jarr = JCALL2(GetLongArrayElements, jenv, $input, 0);
-  if (!jarr) {
-    return $null;
-  }
-#ifdef __cplusplus
-  $1 = new $*1_ltype[sz];
-#else
-  $1 = ($1_ltype) calloc(sz, sizeof($*1_ltype));
-#endif
-  if (!$1) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
-    return $null;
-  }
-  for (i=0; i<sz; i++) {
-    $1[i] = **($&1_ltype)&jarr[i];
-  }
-}
-
-%typemap(argout) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[]
-{
-  int i;
-  for (i=0; i<sz$argnum; i++) {
-    **($&1_ltype)&jarr$argnum[i] = $1[i];
-  }
-  JCALL3(ReleaseLongArrayElements, jenv, $input, jarr$argnum, 0);
-}
-
-%typemap(out) ARRAYSOFCLASSES[ANY]
-{
-  jlong *arr;
-  int i;
-  $result = JCALL1(NewLongArray, jenv, $1_dim0);
-  if (!$result) {
-    return $null;
-  }
-  arr = JCALL2(GetLongArrayElements, jenv, $result, 0);
-  if (!arr) {
-    return $null;
-  }
-  for (i=0; i<$1_dim0; i++) {
-    arr[i] = 0;
-    *($&1_ltype)&arr[i] = &$1[i];
-  }
-  JCALL3(ReleaseLongArrayElements, jenv, $result, arr, 0);
-}
-
-%typemap(freearg) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[]
-#ifdef __cplusplus
-%{ delete [] $1; %}
-#else
-%{ free($1); %}
-#endif
-
-/* Add some code to the proxy class of the array type for converting between type used in 
- * JNI class (long[]) and type used in proxy class ( ARRAYSOFCLASSES[] ) */
-%typemap(javacode) ARRAYSOFCLASSES %{
-  protected static long[] cArrayUnwrap($javaclassname[] arrayWrapper) {
-      long[] cArray = new long[arrayWrapper.length];
-      for (int i=0; i<arrayWrapper.length; i++)
-        cArray[i] = $javaclassname.getCPtr(arrayWrapper[i]);
-      return cArray;
-  }
-
-  protected static $javaclassname[] cArrayWrap(long[] cArray, boolean cMemoryOwn) {
-    $javaclassname[] arrayWrapper = new $javaclassname[cArray.length];
-    for (int i=0; i<cArray.length; i++)
-      arrayWrapper[i] = new $javaclassname(cArray[i], cMemoryOwn);
-    return arrayWrapper;
-  }
-%}
-
-%enddef /* JAVA_ARRAYSOFCLASSES */
-
-
-/* Arrays of enums. 
- * Use the following to use these typemaps for an array of enums called name:
- * %apply ARRAYSOFENUMS[ANY] { name[ANY] }; */
-%typemap(jni) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] "jintArray"
-%typemap(jtype) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] "int[]"
-%typemap(jstype) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] "int[]"
-
-%typemap(javain) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] "$javainput"
-%typemap(javaout) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] {
-    return $jnicall;
-  }
-
-%typemap(in) ARRAYSOFENUMS[] (jint *jarr)
-%{  if (!SWIG_JavaArrayInInt(jenv, &jarr, (int **)&$1, $input)) return $null; %}
-%typemap(in) ARRAYSOFENUMS[ANY] (jint *jarr) {
-  if ($input && JCALL1(GetArrayLength, jenv, $input) != $1_size) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
-    return $null;
-  }
-  if (!SWIG_JavaArrayInInt(jenv, &jarr, (int **)&$1, $input)) return $null;
-}
-%typemap(argout) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] 
-%{ SWIG_JavaArrayArgoutInt(jenv, jarr$argnum, (int *)$1, $input); %}
-%typemap(out) ARRAYSOFENUMS[ANY] 
-%{$result = SWIG_JavaArrayOutInt(jenv, (int *)$1, $1_dim0); %}
-%typemap(freearg) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] 
-#ifdef __cplusplus
-%{ delete [] $1; %}
-#else
-%{ free($1); %}
-#endif
-
diff --git a/share/swig/2.0.11/java/boost_intrusive_ptr.i b/share/swig/2.0.11/java/boost_intrusive_ptr.i
deleted file mode 100644
index f952589..0000000
--- a/share/swig/2.0.11/java/boost_intrusive_ptr.i
+++ /dev/null
@@ -1,473 +0,0 @@
-// 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_NO_WRAP
-#define SWIG_INTRUSIVE_PTR_TYPEMAPS_NO_WRAP(CONST, TYPE...) SWIG_INTRUSIVE_PTR_TYPEMAPS_NO_WRAP_IMPLEMENTATION(protected, protected, CONST, TYPE)
-#endif
-#ifndef SWIG_INTRUSIVE_PTR_TYPEMAPS
-#define SWIG_INTRUSIVE_PTR_TYPEMAPS(CONST, TYPE...) SWIG_INTRUSIVE_PTR_TYPEMAPS_IMPLEMENTATION(protected, protected, 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) 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_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null $1_type");
-    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) 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) 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_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null");
-    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 > ($&1_type argp, 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(result.get());
-  	*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(result.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 (jni)    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 > *& "jlong"
-%typemap (jtype)  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 > *& "long"
-%typemap (jstype) 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(jstype, TYPE)"
-%typemap(javain) 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(jstype, TYPE).getCPtr($javainput)"
-
-%typemap(javaout) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > {
-    long cPtr = $jnicall;
-    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
-  }
-%typemap(javaout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
-    long cPtr = $jnicall;
-    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
-  }
-%typemap(javaout) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > & {
-    long cPtr = $jnicall;
-    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
-  }
-%typemap(javaout) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > * {
-    long cPtr = $jnicall;
-    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
-  }
-%typemap(javaout) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *& {
-    long cPtr = $jnicall;
-    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
-  }
-
-
-%typemap(javaout) CONST TYPE {
-    return new $typemap(jstype, TYPE)($jnicall, true);
-  }
-%typemap(javaout) CONST TYPE & {
-    return new $typemap(jstype, TYPE)($jnicall, true);
-  }
-%typemap(javaout) CONST TYPE * {
-    long cPtr = $jnicall;
-    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
-  }
-%typemap(javaout) TYPE *CONST& {
-    long cPtr = $jnicall;
-    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
-  }
-
-// Base proxy classes
-%typemap(javabody) TYPE %{
-  private long swigCPtr;
-  private boolean swigCMemOwnBase;
-
-  PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
-    swigCMemOwnBase = cMemoryOwn;
-    swigCPtr = cPtr;
-  }
-
-  CPTR_VISIBILITY static long getCPtr($javaclassname obj) {
-    return (obj == null) ? 0 : obj.swigCPtr;
-  }
-%}
-
-// Derived proxy classes
-%typemap(javabody_derived) TYPE %{
-  private long swigCPtr;
-  private boolean swigCMemOwnDerived;
-
-  PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
-    super($imclassname.$javaclazznameSWIGSmartPtrUpcast(cPtr), true);
-    swigCMemOwnDerived = cMemoryOwn;
-    swigCPtr = cPtr;
-  }
-
-  CPTR_VISIBILITY static long getCPtr($javaclassname obj) {
-    return (obj == null) ? 0 : obj.swigCPtr;
-  }
-%}
-
-%typemap(javadestruct, methodname="delete", methodmodifiers="public synchronized") TYPE {
-    if(swigCPtr != 0 && swigCMemOwnBase) {
-      swigCMemOwnBase = false;
-      $jnicall;
-    }
-    swigCPtr = 0;
-  }
-
-%typemap(javadestruct_derived, methodname="delete", methodmodifiers="public synchronized") TYPE {
-    if(swigCPtr != 0 && swigCMemOwnDerived) {
-      swigCMemOwnDerived = false;
-      $jnicall;
-    }
-    swigCPtr = 0;
-    super.delete();
-  }
-
-// CONST version needed ???? also for C#
-%typemap(jtype, nopgcpp="1") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > swigSharedPtrUpcast "long"
-%typemap(jtype, nopgcpp="1") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > swigSharedPtrUpcast "long"
-
-
-%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) 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_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null $1_type");
-    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) 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_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null");
-    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 (jni)    SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > "jlong"
-%typemap (jtype)  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > "long"
-%typemap (jstype) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > "$typemap(jstype, TYPE)"
-%typemap (javain) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > "$typemap(jstype, TYPE).getCPtr($javainput)"
-%typemap(javaout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
-    long cPtr = $jnicall;
-    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
-  }
-
-%typemap(javaout) CONST TYPE {
-    return new $typemap(jstype, TYPE)($jnicall, true);
-  }
-%typemap(javaout) CONST TYPE & {
-    return new $typemap(jstype, TYPE)($jnicall, true);
-  }
-%typemap(javaout) CONST TYPE * {
-    long cPtr = $jnicall;
-    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
-  }
-%typemap(javaout) TYPE *CONST& {
-    long cPtr = $jnicall;
-    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
-  }
-
-// Base proxy classes
-%typemap(javabody) TYPE %{
-  private long swigCPtr;
-  private boolean swigCMemOwnBase;
-
-  PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
-    swigCMemOwnBase = cMemoryOwn;
-    swigCPtr = cPtr;
-  }
-
-  CPTR_VISIBILITY static long getCPtr($javaclassname obj) {
-    return (obj == null) ? 0 : obj.swigCPtr;
-  }
-%}
-
-// Derived proxy classes
-%typemap(javabody_derived) TYPE %{
-  private long swigCPtr;
-  private boolean swigCMemOwnDerived;
-
-  PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
-    super($imclassname.$javaclazznameSWIGSmartPtrUpcast(cPtr), true);
-    swigCMemOwnDerived = cMemoryOwn;
-    swigCPtr = cPtr;
-  }
-
-  CPTR_VISIBILITY static long getCPtr($javaclassname obj) {
-    return (obj == null) ? 0 : obj.swigCPtr;
-  }
-%}
-
-%typemap(javadestruct, methodname="delete", methodmodifiers="public synchronized") TYPE {
-    if (swigCPtr != 0) {
-      if (swigCMemOwnBase) {
-        swigCMemOwnBase = false;
-        $jnicall;
-      }
-      swigCPtr = 0;
-    }
-  }
-
-%typemap(javadestruct_derived, methodname="delete", methodmodifiers="public synchronized") TYPE {
-    if (swigCPtr != 0) {
-      if (swigCMemOwnDerived) {
-        swigCMemOwnDerived = false;
-        $jnicall;
-      }
-      swigCPtr = 0;
-    }
-    super.delete();
-  }
-
-// CONST version needed ???? also for C#
-%typemap(jtype, nopgcpp="1") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > swigSharedPtrUpcast "long"
-%typemap(jtype, nopgcpp="1") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > swigSharedPtrUpcast "long"
-
-
-%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
-%enddef
-
diff --git a/share/swig/2.0.11/java/boost_shared_ptr.i b/share/swig/2.0.11/java/boost_shared_ptr.i
deleted file mode 100644
index e752369..0000000
--- a/share/swig/2.0.11/java/boost_shared_ptr.i
+++ /dev/null
@@ -1,201 +0,0 @@
-// 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(protected, protected, 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 wrapper customisation
-%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) 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_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null $1_type");
-    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) 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_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null");
-    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 = (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&
-%{ *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$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 > ($&1_type argp)
-%{ argp = *($&1_ltype*)&$input; 
-   if (argp) $1 = *argp; %}
-%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >
-%{ *($&1_ltype*)&$result = $1 ? new $1_ltype($1) : 0; %}
-
-// shared_ptr by reference
-%typemap(in) 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 > &
-%{ *($&1_ltype)&$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) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *
-%{ *($&1_ltype)&$result = ($1 && *$1) ? new $*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 (jni)    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 > *& "jlong"
-%typemap (jtype)  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 > *& "long"
-%typemap (jstype) 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(jstype, TYPE)"
-
-%typemap(javain) 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(jstype, TYPE).getCPtr($javainput)"
-
-%typemap(javaout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
-    long cPtr = $jnicall;
-    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
-  }
-%typemap(javaout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & {
-    long cPtr = $jnicall;
-    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
-  }
-%typemap(javaout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * {
-    long cPtr = $jnicall;
-    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
-  }
-%typemap(javaout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& {
-    long cPtr = $jnicall;
-    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
-  }
-
-
-%typemap(javaout) CONST TYPE {
-    return new $typemap(jstype, TYPE)($jnicall, true);
-  }
-%typemap(javaout) CONST TYPE & {
-    return new $typemap(jstype, TYPE)($jnicall, true);
-  }
-%typemap(javaout) CONST TYPE * {
-    long cPtr = $jnicall;
-    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
-  }
-%typemap(javaout) TYPE *CONST& {
-    long cPtr = $jnicall;
-    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
-  }
-
-// Base proxy classes
-%typemap(javabody) TYPE %{
-  private long swigCPtr;
-  private boolean swigCMemOwn;
-
-  PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = cPtr;
-  }
-
-  CPTR_VISIBILITY static long getCPtr($javaclassname obj) {
-    return (obj == null) ? 0 : obj.swigCPtr;
-  }
-%}
-
-// Derived proxy classes
-%typemap(javabody_derived) TYPE %{
-  private long swigCPtr;
-  private boolean swigCMemOwnDerived;
-
-  PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
-    super($imclassname.$javaclazznameSWIGSmartPtrUpcast(cPtr), true);
-    swigCMemOwnDerived = cMemoryOwn;
-    swigCPtr = cPtr;
-  }
-
-  CPTR_VISIBILITY static long getCPtr($javaclassname obj) {
-    return (obj == null) ? 0 : obj.swigCPtr;
-  }
-%}
-
-%typemap(javadestruct, methodname="delete", methodmodifiers="public synchronized") TYPE {
-    if (swigCPtr != 0) {
-      if (swigCMemOwn) {
-        swigCMemOwn = false;
-        $jnicall;
-      }
-      swigCPtr = 0;
-    }
-  }
-
-%typemap(javadestruct_derived, methodname="delete", methodmodifiers="public synchronized") TYPE {
-    if (swigCPtr != 0) {
-      if (swigCMemOwnDerived) {
-        swigCMemOwnDerived = false;
-        $jnicall;
-      }
-      swigCPtr = 0;
-    }
-    super.delete();
-  }
-
-
-%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
-%enddef
-
diff --git a/share/swig/2.0.11/java/director.swg b/share/swig/2.0.11/java/director.swg
deleted file mode 100644
index f32fda3..0000000
--- a/share/swig/2.0.11/java/director.swg
+++ /dev/null
@@ -1,198 +0,0 @@
-/* -----------------------------------------------------------------------------
- * director.swg
- *
- * This file contains support for director classes that proxy
- * method calls from C++ to Java extensions.
- * ----------------------------------------------------------------------------- */
-
-#ifdef __cplusplus
-
-#if defined(DEBUG_DIRECTOR_OWNED)
-#include <iostream>
-#endif
-
-namespace Swig {
-  /* Java object wrapper */
-  class JObjectWrapper {
-  public:
-    JObjectWrapper() : jthis_(NULL), weak_global_(true) {
-    }
-
-    ~JObjectWrapper() {
-      jthis_ = NULL;
-      weak_global_ = true;
-    }
-
-    bool set(JNIEnv *jenv, jobject jobj, bool mem_own, bool weak_global) {
-      if (!jthis_) {
-        weak_global_ = weak_global || !mem_own; // hold as weak global if explicitly requested or not owned
-        if (jobj)
-          jthis_ = weak_global_ ? jenv->NewWeakGlobalRef(jobj) : jenv->NewGlobalRef(jobj);
-#if defined(DEBUG_DIRECTOR_OWNED)
-        std::cout << "JObjectWrapper::set(" << jobj << ", " << (weak_global ? "weak_global" : "global_ref") << ") -> " << jthis_ << std::endl;
-#endif
-        return true;
-      } else {
-#if defined(DEBUG_DIRECTOR_OWNED)
-        std::cout << "JObjectWrapper::set(" << jobj << ", " << (weak_global ? "weak_global" : "global_ref") << ") -> already set" << std::endl;
-#endif
-        return false;
-      }
-    }
-
-    jobject get(JNIEnv *jenv) const {
-#if defined(DEBUG_DIRECTOR_OWNED)
-      std::cout << "JObjectWrapper::get(";
-      if (jthis_)
-        std::cout << jthis_;
-      else
-        std::cout << "null";
-      std::cout << ") -> return new local ref" << std::endl;
-#endif
-      return (jthis_ ? jenv->NewLocalRef(jthis_) : jthis_);
-    }
-
-    void release(JNIEnv *jenv) {
-#if defined(DEBUG_DIRECTOR_OWNED)
-      std::cout << "JObjectWrapper::release(" << jthis_ << "): " << (weak_global_ ? "weak global ref" : "global ref") << std::endl;
-#endif
-      if (jthis_) {
-        if (weak_global_) {
-          if (jenv->IsSameObject(jthis_, NULL) == JNI_FALSE)
-            jenv->DeleteWeakGlobalRef((jweak)jthis_);
-        } else
-          jenv->DeleteGlobalRef(jthis_);
-      }
-
-      jthis_ = NULL;
-      weak_global_ = true;
-    }
-
-    /* Only call peek if you know what you are doing wrt to weak/global references */
-    jobject peek() {
-      return jthis_;
-    }
-
-    /* Java proxy releases ownership of C++ object, C++ object is now
-       responsible for destruction (creates NewGlobalRef to pin Java
-       proxy) */
-    void java_change_ownership(JNIEnv *jenv, jobject jself, bool take_or_release) {
-      if (take_or_release) {  /* Java takes ownership of C++ object's lifetime. */
-        if (!weak_global_) {
-          jenv->DeleteGlobalRef(jthis_);
-          jthis_ = jenv->NewWeakGlobalRef(jself);
-          weak_global_ = true;
-        }
-      } else { /* Java releases ownership of C++ object's lifetime */
-        if (weak_global_) {
-          jenv->DeleteWeakGlobalRef((jweak)jthis_);
-          jthis_ = jenv->NewGlobalRef(jself);
-          weak_global_ = false;
-        }
-      }
-    }
-
-  private:
-    /* pointer to Java object */
-    jobject jthis_;
-    /* Local or global reference flag */
-    bool weak_global_;
-  };
-
-  /* director base class */
-  class Director {
-    /* pointer to Java virtual machine */
-    JavaVM *swig_jvm_;
-
-  protected:
-#if defined (_MSC_VER) && (_MSC_VER<1300)
-    class JNIEnvWrapper;
-    friend class JNIEnvWrapper;
-#endif
-    /* Utility class for managing the JNI environment */
-    class JNIEnvWrapper {
-      const Director *director_;
-      JNIEnv *jenv_;
-      int env_status;
-    public:
-      JNIEnvWrapper(const Director *director) : director_(director), jenv_(0), env_status(0) {
-#if defined(__ANDROID__)
-        JNIEnv **jenv = &jenv_;
-#else
-        void **jenv = (void **)&jenv_;
-#endif
-        env_status = director_->swig_jvm_->GetEnv((void **)&jenv_, JNI_VERSION_1_2);
-#if defined(SWIG_JAVA_ATTACH_CURRENT_THREAD_AS_DAEMON)
-        // Attach a daemon thread to the JVM. Useful when the JVM should not wait for 
-        // the thread to exit upon shutdown. Only for jdk-1.4 and later.
-        director_->swig_jvm_->AttachCurrentThreadAsDaemon(jenv, NULL);
-#else
-        director_->swig_jvm_->AttachCurrentThread(jenv, NULL);
-#endif
-      }
-      ~JNIEnvWrapper() {
-#if !defined(SWIG_JAVA_NO_DETACH_CURRENT_THREAD)
-        // Some JVMs, eg jdk-1.4.2 and lower on Solaris have a bug and crash with the DetachCurrentThread call.
-        // However, without this call, the JVM hangs on exit when the thread was not created by the JVM and creates a memory leak.
-        if (env_status == JNI_EDETACHED)
-          director_->swig_jvm_->DetachCurrentThread();
-#endif
-      }
-      JNIEnv *getJNIEnv() const {
-        return jenv_;
-      }
-    };
-
-    /* Java object wrapper */
-    JObjectWrapper swig_self_;
-
-    /* Disconnect director from Java object */
-    void swig_disconnect_director_self(const char *disconn_method) {
-      JNIEnvWrapper jnienv(this) ;
-      JNIEnv *jenv = jnienv.getJNIEnv() ;
-      jobject jobj = swig_self_.get(jenv);
-#if defined(DEBUG_DIRECTOR_OWNED)
-      std::cout << "Swig::Director::disconnect_director_self(" << jobj << ")" << std::endl;
-#endif
-      if (jobj && jenv->IsSameObject(jobj, NULL) == JNI_FALSE) {
-        jmethodID disconn_meth = jenv->GetMethodID(jenv->GetObjectClass(jobj), disconn_method, "()V");
-        if (disconn_meth) {
-#if defined(DEBUG_DIRECTOR_OWNED)
-          std::cout << "Swig::Director::disconnect_director_self upcall to " << disconn_method << std::endl;
-#endif
-          jenv->CallVoidMethod(jobj, disconn_meth);
-        }
-      }
-      jenv->DeleteLocalRef(jobj);
-    }
-
-  public:
-    Director(JNIEnv *jenv) : swig_jvm_((JavaVM *) NULL), swig_self_() {
-      /* Acquire the Java VM pointer */
-      jenv->GetJavaVM(&swig_jvm_);
-    }
-
-    virtual ~Director() {
-      JNIEnvWrapper jnienv(this) ;
-      JNIEnv *jenv = jnienv.getJNIEnv() ;
-      swig_self_.release(jenv);
-    }
-
-    bool swig_set_self(JNIEnv *jenv, jobject jself, bool mem_own, bool weak_global) {
-      return swig_self_.set(jenv, jself, mem_own, weak_global);
-    }
-
-    jobject swig_get_self(JNIEnv *jenv) const {
-      return swig_self_.get(jenv);
-    }
-
-    // Change C++ object's ownership, relative to Java
-    void swig_java_change_ownership(JNIEnv *jenv, jobject jself, bool take_or_release) {
-      swig_self_.java_change_ownership(jenv, jself, take_or_release);
-    }
-  };
-}
-
-#endif /* __cplusplus */
-
-
diff --git a/share/swig/2.0.11/java/enums.swg b/share/swig/2.0.11/java/enums.swg
deleted file mode 100644
index b8b7f9e..0000000
--- a/share/swig/2.0.11/java/enums.swg
+++ /dev/null
@@ -1,117 +0,0 @@
-/* -----------------------------------------------------------------------------
- * enums.swg
- *
- * Include this file in order for C/C++ enums to be wrapped by proper Java enums.
- * Note that the JNI layer handles the enum as an int. The Java enum has extra
- * code generated to store the C++ int value. This is required for C++ enums that
- * specify a value for the enum item, as native Java enums do not support this.
- * ----------------------------------------------------------------------------- */
-
-// const enum SWIGTYPE & typemaps
-%typemap(jni) const enum SWIGTYPE & "jint"
-%typemap(jtype) const enum SWIGTYPE & "int"
-%typemap(jstype) const enum SWIGTYPE & "$*javaclassname"
-
-%typemap(in) const enum SWIGTYPE & ($*1_ltype temp)
-%{ temp = ($*1_ltype)$input; 
-   $1 = &temp; %}
-%typemap(out) const enum SWIGTYPE &  %{ $result = (jint)*$1; %}
-
-%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const enum SWIGTYPE &
-%{ static $*1_ltype temp = ($*1_ltype)$input; 
-   $result = &temp; %}
-%typemap(directorin, descriptor="L$packagepath/$*javaclassname;") const enum SWIGTYPE & "$input = (jint)$1;"
-%typemap(javadirectorin) const enum SWIGTYPE & "$*javaclassname.swigToEnum($jniinput)"
-%typemap(javadirectorout) const enum SWIGTYPE & "($javacall).swigValue()"
-
-%typecheck(SWIG_TYPECHECK_POINTER) const enum SWIGTYPE & ""
-
-%typemap(throws) const enum SWIGTYPE &
-%{ (void)$1;
-   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown"); %}
-
-%typemap(javain) const enum SWIGTYPE & "$javainput.swigValue()"
-%typemap(javaout) const enum SWIGTYPE & {
-    return $*javaclassname.swigToEnum($jnicall);
-  }
-
-
-// enum SWIGTYPE typemaps
-%typemap(jni) enum SWIGTYPE "jint"
-%typemap(jtype) enum SWIGTYPE "int"
-%typemap(jstype) enum SWIGTYPE "$javaclassname"
-
-%typemap(in) enum SWIGTYPE  %{ $1 = ($1_ltype)$input; %}
-%typemap(out) enum SWIGTYPE  %{ $result = (jint)$1; %}
-
-%typemap(directorout) enum SWIGTYPE  %{ $result = ($1_ltype)$input; %}
-%typemap(directorin, descriptor="L$packagepath/$javaclassname;") enum SWIGTYPE "$input = (jint) $1;"
-%typemap(javadirectorin) enum SWIGTYPE "$javaclassname.swigToEnum($jniinput)"
-%typemap(javadirectorout) enum SWIGTYPE "($javacall).swigValue()"
-
-%typecheck(SWIG_TYPECHECK_POINTER) enum SWIGTYPE ""
-
-%typemap(throws) enum SWIGTYPE
-%{ (void)$1;
-   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown"); %}
-
-%typemap(javain) enum SWIGTYPE "$javainput.swigValue()"
-%typemap(javaout) enum SWIGTYPE {
-    return $javaclassname.swigToEnum($jnicall);
-  }
-
-%typemap(javaclassmodifiers) enum SWIGTYPE "public enum"
-%typemap(javabase)           enum SWIGTYPE ""
-%typemap(javacode)           enum SWIGTYPE ""
-%typemap(javaimports)        enum SWIGTYPE ""
-%typemap(javainterfaces)     enum SWIGTYPE ""
-%typemap(javabody)           enum SWIGTYPE ""
-
-/*
- * SwigNext static inner class used instead of a static int as static fields cannot be accessed from enum initialisers.
- * The swigToEnum method is used to find the Java 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.
- */
-%typemap(javabody) enum SWIGTYPE %{
-  public final int swigValue() {
-    return swigValue;
-  }
-
-  public static $javaclassname swigToEnum(int swigValue) {
-    $javaclassname[] swigValues = $javaclassname.class.getEnumConstants();
-    if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue)
-      return swigValues[swigValue];
-    for ($javaclassname swigEnum : swigValues)
-      if (swigEnum.swigValue == swigValue)
-        return swigEnum;
-    throw new IllegalArgumentException("No enum " + $javaclassname.class + " with value " + swigValue);
-  }
-
-  @SuppressWarnings("unused")
-  private $javaclassname() {
-    this.swigValue = SwigNext.next++;
-  }
-
-  @SuppressWarnings("unused")
-  private $javaclassname(int swigValue) {
-    this.swigValue = swigValue;
-    SwigNext.next = swigValue+1;
-  }
-
-  @SuppressWarnings("unused")
-  private $javaclassname($javaclassname swigEnum) {
-    this.swigValue = swigEnum.swigValue;
-    SwigNext.next = this.swigValue+1;
-  }
-
-  private final int swigValue;
-
-  private static class SwigNext {
-    private static int next = 0;
-  }
-%}
-
-%javaenum(proper);
-
diff --git a/share/swig/2.0.11/java/enumtypesafe.swg b/share/swig/2.0.11/java/enumtypesafe.swg
deleted file mode 100644
index 976364b..0000000
--- a/share/swig/2.0.11/java/enumtypesafe.swg
+++ /dev/null
@@ -1,118 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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 Java class named after the
- * enum and each enum item is a static instance of this class.
- * ----------------------------------------------------------------------------- */
-
-// const enum SWIGTYPE & typemaps
-%typemap(jni) const enum SWIGTYPE & "jint"
-%typemap(jtype) const enum SWIGTYPE & "int"
-%typemap(jstype) const enum SWIGTYPE & "$*javaclassname"
-
-%typemap(in) const enum SWIGTYPE & ($*1_ltype temp)
-%{ temp = ($*1_ltype)$input; 
-   $1 = &temp; %}
-%typemap(out) const enum SWIGTYPE &  %{ $result = (jint)*$1; %}
-
-%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const enum SWIGTYPE &
-%{ static $*1_ltype temp = ($*1_ltype)$input; 
-   $result = &temp; %}
-%typemap(directorin, descriptor="L$packagepath/$*javaclassname;") const enum SWIGTYPE & "$input = (jint)$1;"
-%typemap(javadirectorin) const enum SWIGTYPE & "$*javaclassname.swigToEnum($jniinput)"
-%typemap(javadirectorout) const enum SWIGTYPE & "($javacall).swigValue()"
-
-%typecheck(SWIG_TYPECHECK_POINTER) const enum SWIGTYPE & ""
-
-%typemap(throws) const enum SWIGTYPE &
-%{ (void)$1;
-   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown"); %}
-
-%typemap(javain) const enum SWIGTYPE & "$javainput.swigValue()"
-%typemap(javaout) const enum SWIGTYPE & {
-    return $*javaclassname.swigToEnum($jnicall);
-  }
-
-// enum SWIGTYPE typemaps
-%typemap(jni) enum SWIGTYPE "jint"
-%typemap(jtype) enum SWIGTYPE "int"
-%typemap(jstype) enum SWIGTYPE "$javaclassname"
-
-%typemap(in) enum SWIGTYPE  %{ $1 = ($1_ltype)$input; %}
-%typemap(out) enum SWIGTYPE  %{ $result = (jint)$1; %}
-
-%typemap(directorout) enum SWIGTYPE  %{ $result = ($1_ltype)$input; %}
-%typemap(directorin, descriptor="L$packagepath/$javaclassname;") enum SWIGTYPE "$input = (jint) $1;"
-%typemap(javadirectorin) enum SWIGTYPE "$javaclassname.swigToEnum($jniinput)"
-%typemap(javadirectorout) enum SWIGTYPE "($javacall).swigValue()"
-
-%typecheck(SWIG_TYPECHECK_POINTER) enum SWIGTYPE ""
-
-%typemap(throws) enum SWIGTYPE
-%{ (void)$1;
-   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown"); %}
-
-%typemap(javain) enum SWIGTYPE "$javainput.swigValue()"
-%typemap(javaout) enum SWIGTYPE {
-    return $javaclassname.swigToEnum($jnicall);
-  }
-
-// '$static' will be replaced with either 'static' or nothing depending on whether the enum is an inner Java class or not
-%typemap(javaclassmodifiers) enum SWIGTYPE "public final $static class"
-%typemap(javabase)           enum SWIGTYPE ""
-%typemap(javacode)           enum SWIGTYPE ""
-%typemap(javaimports)        enum SWIGTYPE ""
-%typemap(javainterfaces)     enum SWIGTYPE ""
-%typemap(javabody)           enum SWIGTYPE ""
-
-/*
- * The swigToEnum method is used to find the Java 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(javabody) enum SWIGTYPE %{
-  public final int swigValue() {
-    return swigValue;
-  }
-
-  public String toString() {
-    return swigName;
-  }
-
-  public static $javaclassname 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 IllegalArgumentException("No enum " + $javaclassname.class + " with value " + swigValue);
-  }
-
-  private $javaclassname(String swigName) {
-    this.swigName = swigName;
-    this.swigValue = swigNext++;
-  }
-
-  private $javaclassname(String swigName, int swigValue) {
-    this.swigName = swigName;
-    this.swigValue = swigValue;
-    swigNext = swigValue+1;
-  }
-
-  private $javaclassname(String swigName, $javaclassname swigEnum) {
-    this.swigName = swigName;
-    this.swigValue = swigEnum.swigValue;
-    swigNext = this.swigValue+1;
-  }
-
-  private static $javaclassname[] swigValues = { $enumvalues };
-  private static int swigNext = 0;
-  private final int swigValue;
-  private final String swigName;
-%}
-
-%javaenum(typesafe);
-
diff --git a/share/swig/2.0.11/java/java.swg b/share/swig/2.0.11/java/java.swg
deleted file mode 100644
index 6126a55..0000000
--- a/share/swig/2.0.11/java/java.swg
+++ /dev/null
@@ -1,1329 +0,0 @@
-/* -----------------------------------------------------------------------------
- * java.swg
- *
- * Java typemaps
- * ----------------------------------------------------------------------------- */
-
-%include <javahead.swg>
-
-/* The jni, jtype and jstype typemaps work together and so there should be one of each. 
- * The jni typemap contains the JNI type used in the JNI (C/C++) code. 
- * The jtype typemap contains the Java type used in the JNI intermediary class. 
- * The jstype typemap contains the Java type used in the Java 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(jni) bool,               const bool &               "jboolean"
-%typemap(jni) char,               const char &               "jchar"
-%typemap(jni) signed char,        const signed char &        "jbyte"
-%typemap(jni) unsigned char,      const unsigned char &      "jshort"
-%typemap(jni) short,              const short &              "jshort"
-%typemap(jni) unsigned short,     const unsigned short &     "jint"
-%typemap(jni) int,                const int &                "jint"
-%typemap(jni) unsigned int,       const unsigned int &       "jlong"
-%typemap(jni) long,               const long &               "jint"
-%typemap(jni) unsigned long,      const unsigned long &      "jlong"
-%typemap(jni) long long,          const long long &          "jlong"
-%typemap(jni) unsigned long long, const unsigned long long & "jobject"
-%typemap(jni) float,              const float &              "jfloat"
-%typemap(jni) double,             const double &             "jdouble"
-%typemap(jni) void                                           "void"
-
-%typemap(jtype) bool,               const bool &               "boolean"
-%typemap(jtype) char,               const char &               "char"
-%typemap(jtype) signed char,        const signed char &        "byte"
-%typemap(jtype) unsigned char,      const unsigned char &      "short"
-%typemap(jtype) short,              const short &              "short"
-%typemap(jtype) unsigned short,     const unsigned short &     "int"
-%typemap(jtype) int,                const int &                "int"
-%typemap(jtype) unsigned int,       const unsigned int &       "long"
-%typemap(jtype) long,               const long &               "int"
-%typemap(jtype) unsigned long,      const unsigned long &      "long"
-%typemap(jtype) long long,          const long long &          "long"
-%typemap(jtype) unsigned long long, const unsigned long long & "java.math.BigInteger"
-%typemap(jtype) float,              const float &              "float"
-%typemap(jtype) double,             const double &             "double"
-%typemap(jtype) void                                           "void"
-
-%typemap(jstype) bool,               const bool &               "boolean"
-%typemap(jstype) char,               const char &               "char"
-%typemap(jstype) signed char,        const signed char &        "byte"
-%typemap(jstype) unsigned char,      const unsigned char &      "short"
-%typemap(jstype) short,              const short &              "short"
-%typemap(jstype) unsigned short,     const unsigned short &     "int"
-%typemap(jstype) int,                const int &                "int"
-%typemap(jstype) unsigned int,       const unsigned int &       "long"
-%typemap(jstype) long,               const long &               "int"
-%typemap(jstype) unsigned long,      const unsigned long &      "long"
-%typemap(jstype) long long,          const long long &          "long"
-%typemap(jstype) unsigned long long, const unsigned long long & "java.math.BigInteger"
-%typemap(jstype) float,              const float &              "float"
-%typemap(jstype) double,             const double &             "double"
-%typemap(jstype) void                                           "void"
-
-%typemap(jni) char *, char *&, char[ANY], char[]               "jstring"
-%typemap(jtype) char *, char *&, char[ANY], char[]               "String"
-%typemap(jstype) char *, char *&, char[ANY], char[]               "String"
-
-/* JNI types */
-%typemap(jni) jboolean      "jboolean"
-%typemap(jni) jchar         "jchar"
-%typemap(jni) jbyte         "jbyte"
-%typemap(jni) jshort        "jshort"
-%typemap(jni) jint          "jint"
-%typemap(jni) jlong         "jlong"
-%typemap(jni) jfloat        "jfloat"
-%typemap(jni) jdouble       "jdouble"
-%typemap(jni) jstring       "jstring"
-%typemap(jni) jobject       "jobject"
-%typemap(jni) jbooleanArray "jbooleanArray"
-%typemap(jni) jcharArray    "jcharArray"
-%typemap(jni) jbyteArray    "jbyteArray"
-%typemap(jni) jshortArray   "jshortArray"
-%typemap(jni) jintArray     "jintArray"
-%typemap(jni) jlongArray    "jlongArray"
-%typemap(jni) jfloatArray   "jfloatArray"
-%typemap(jni) jdoubleArray  "jdoubleArray"
-%typemap(jni) jobjectArray  "jobjectArray"
-
-%typemap(jtype) jboolean      "boolean"
-%typemap(jtype) jchar         "char"
-%typemap(jtype) jbyte         "byte"
-%typemap(jtype) jshort        "short"
-%typemap(jtype) jint          "int"
-%typemap(jtype) jlong         "long"
-%typemap(jtype) jfloat        "float"
-%typemap(jtype) jdouble       "double"
-%typemap(jtype) jstring       "String"
-%typemap(jtype) jobject       "Object"
-%typemap(jtype) jbooleanArray "boolean[]"
-%typemap(jtype) jcharArray    "char[]"
-%typemap(jtype) jbyteArray    "byte[]"
-%typemap(jtype) jshortArray   "short[]"
-%typemap(jtype) jintArray     "int[]"
-%typemap(jtype) jlongArray    "long[]"
-%typemap(jtype) jfloatArray   "float[]"
-%typemap(jtype) jdoubleArray  "double[]"
-%typemap(jtype) jobjectArray  "Object[]"
-
-%typemap(jstype) jboolean      "boolean"
-%typemap(jstype) jchar         "char"
-%typemap(jstype) jbyte         "byte"
-%typemap(jstype) jshort        "short"
-%typemap(jstype) jint          "int"
-%typemap(jstype) jlong         "long"
-%typemap(jstype) jfloat        "float"
-%typemap(jstype) jdouble       "double"
-%typemap(jstype) jstring       "String"
-%typemap(jstype) jobject       "Object"
-%typemap(jstype) jbooleanArray "boolean[]"
-%typemap(jstype) jcharArray    "char[]"
-%typemap(jstype) jbyteArray    "byte[]"
-%typemap(jstype) jshortArray   "short[]"
-%typemap(jstype) jintArray     "int[]"
-%typemap(jstype) jlongArray    "long[]"
-%typemap(jstype) jfloatArray   "float[]"
-%typemap(jstype) jdoubleArray  "double[]"
-%typemap(jstype) jobjectArray  "Object[]"
-
-/* Non primitive types */
-%typemap(jni) SWIGTYPE "jlong"
-%typemap(jtype) SWIGTYPE "long"
-%typemap(jstype) SWIGTYPE "$&javaclassname"
-
-%typemap(jni) SWIGTYPE [] "jlong"
-%typemap(jtype) SWIGTYPE [] "long"
-%typemap(jstype) SWIGTYPE [] "$javaclassname"
-
-%typemap(jni) SWIGTYPE * "jlong"
-%typemap(jtype) SWIGTYPE * "long"
-%typemap(jstype) SWIGTYPE * "$javaclassname"
-
-%typemap(jni) SWIGTYPE & "jlong"
-%typemap(jtype) SWIGTYPE & "long"
-%typemap(jstype) SWIGTYPE & "$javaclassname"
-
-/* pointer to a class member */
-%typemap(jni) SWIGTYPE (CLASS::*) "jstring"
-%typemap(jtype) SWIGTYPE (CLASS::*) "String"
-%typemap(jstype) SWIGTYPE (CLASS::*) "$javaclassname"
-
-/* The following are the in, out, freearg, argout typemaps. These are the JNI code generating typemaps for converting from Java to C and visa versa. */
-
-/* primitive types */
-%typemap(in) bool
-%{ $1 = $input ? true : false; %}
-
-%typemap(directorout) bool
-%{ $result = $input ? true : false; %}
-
-%typemap(javadirectorin) bool "$jniinput"
-%typemap(javadirectorout) bool "$javacall"
-
-%typemap(in) char, 
-             signed char, 
-             unsigned char, 
-             short, 
-             unsigned short, 
-             int, 
-             unsigned int, 
-             long, 
-             unsigned long, 
-             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, 
-             float, 
-             double
-%{ $result = ($1_ltype)$input; %}
-
-%typemap(directorin, descriptor="Z") bool             "$input = (jboolean) $1;"
-%typemap(directorin, descriptor="C") char             "$input = (jint) $1;"
-%typemap(directorin, descriptor="B") signed char      "$input = (jbyte) $1;"
-%typemap(directorin, descriptor="S") unsigned char    "$input = (jshort) $1;"
-%typemap(directorin, descriptor="S") short            "$input = (jshort) $1;"
-%typemap(directorin, descriptor="I") unsigned short   "$input = (jint) $1;"
-%typemap(directorin, descriptor="I") int              "$input = (jint) $1;"
-%typemap(directorin, descriptor="J") unsigned int     "$input = (jlong) $1;"
-%typemap(directorin, descriptor="I") long             "$input = (jint) $1;"
-%typemap(directorin, descriptor="J") unsigned long    "$input = (jlong) $1;"
-%typemap(directorin, descriptor="J") long long        "$input = (jlong) $1;"
-%typemap(directorin, descriptor="F") float            "$input = (jfloat) $1;"
-%typemap(directorin, descriptor="D") double           "$input = (jdouble) $1;"
-
-%typemap(javadirectorin) char, 
-                         signed char, 
-                         unsigned char, 
-                         short, 
-                         unsigned short, 
-                         int, 
-                         unsigned int, 
-                         long, 
-                         unsigned long, 
-                         long long, 
-                         float, 
-                         double
-  "$jniinput"
-
-%typemap(javadirectorout) char, 
-                          signed char, 
-                          unsigned char, 
-                          short, 
-                          unsigned short, 
-                          int, 
-                          unsigned int, 
-                          long, 
-                          unsigned long, 
-                          long long, 
-                          float, 
-                          double
-  "$javacall"
-
-%typemap(out) bool           %{ $result = (jboolean)$1; %}
-%typemap(out) char           %{ $result = (jchar)$1; %}
-%typemap(out) signed char    %{ $result = (jbyte)$1; %}
-%typemap(out) unsigned char  %{ $result = (jshort)$1; %}
-%typemap(out) short          %{ $result = (jshort)$1; %}
-%typemap(out) unsigned short %{ $result = (jint)$1; %}
-%typemap(out) int            %{ $result = (jint)$1; %}
-%typemap(out) unsigned int   %{ $result = (jlong)$1; %}
-%typemap(out) long           %{ $result = (jint)$1; %}
-%typemap(out) unsigned long  %{ $result = (jlong)$1; %}
-%typemap(out) long long      %{ $result = (jlong)$1; %}
-%typemap(out) float          %{ $result = (jfloat)$1; %}
-%typemap(out) double         %{ $result = (jdouble)$1; %}
-
-/* unsigned long long */
-/* Convert from BigInteger using the toByteArray member function */
-%typemap(in) unsigned long long { 
-  jclass clazz;
-  jmethodID mid;
-  jbyteArray ba;
-  jbyte* bae;
-  jsize sz;
-  int i;
-
-  if (!$input) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
-    return $null;
-  }
-  clazz = JCALL1(GetObjectClass, jenv, $input);
-  mid = JCALL3(GetMethodID, jenv, clazz, "toByteArray", "()[B");
-  ba = (jbyteArray)JCALL2(CallObjectMethod, jenv, $input, mid);
-  bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
-  sz = JCALL1(GetArrayLength, jenv, ba);
-  $1 = 0;
-  for(i=0; i<sz; i++) {
-    $1 = ($1 << 8) | ($1_type)(unsigned char)bae[i];
-  }
-  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
-}
-
-%typemap(directorout) unsigned long long { 
-  jclass clazz;
-  jmethodID mid;
-  jbyteArray ba;
-  jbyte* bae;
-  jsize sz;
-  int i;
-
-  if (!$input) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
-    return $null;
-  }
-  clazz = JCALL1(GetObjectClass, jenv, $input);
-  mid = JCALL3(GetMethodID, jenv, clazz, "toByteArray", "()[B");
-  ba = (jbyteArray)JCALL2(CallObjectMethod, jenv, $input, mid);
-  bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
-  sz = JCALL1(GetArrayLength, jenv, ba);
-  $result = 0;
-  for(i=0; i<sz; i++) {
-    $result = ($result << 8) | ($1_type)(unsigned char)bae[i];
-  }
-  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
-}
-
-
-/* Convert to BigInteger - byte array holds number in 2's complement big endian format */
-%typemap(out) unsigned long long { 
-  jbyteArray ba = JCALL1(NewByteArray, jenv, 9);
-  jbyte* bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
-  jclass clazz = JCALL1(FindClass, jenv, "java/math/BigInteger");
-  jmethodID mid = JCALL3(GetMethodID, jenv, clazz, "<init>", "([B)V");
-  jobject bigint;
-  int i;
-
-  bae[0] = 0;
-  for(i=1; i<9; i++ ) {
-    bae[i] = (jbyte)($1>>8*(8-i));
-  }
-
-  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
-  bigint = JCALL3(NewObject, jenv, clazz, mid, ba);
-  $result = bigint;
-}
-
-/* Convert to BigInteger (see out typemap) */
-%typemap(directorin, descriptor="Ljava/math/BigInteger;") unsigned long long, const unsigned long long & {
-  jbyteArray ba = JCALL1(NewByteArray, jenv, 9);
-  jbyte* bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
-  jclass clazz = JCALL1(FindClass, jenv, "java/math/BigInteger");
-  jmethodID mid = JCALL3(GetMethodID, jenv, clazz, "<init>", "([B)V");
-  jobject bigint;
-  int swig_i;
-
-  bae[0] = 0;
-  for(swig_i=1; swig_i<9; swig_i++ ) {
-    bae[swig_i] = (jbyte)($1>>8*(8-swig_i));
-  }
-
-  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
-  bigint = JCALL3(NewObject, jenv, clazz, mid, ba);
-  $input = bigint;
-}
-
-%typemap(javadirectorin) unsigned long long "$jniinput"
-%typemap(javadirectorout) unsigned long long "$javacall"
-
-/* char * - treat as String */
-%typemap(in, noblock=1) char * {
- $1 = 0;
-  if ($input) {
-    $1 = ($1_ltype)JCALL2(GetStringUTFChars, jenv, $input, 0);
-    if (!$1) return $null;
-  }
-}
-
-%typemap(directorout, noblock=1, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) char * {
-  $1 = 0;
-  if ($input) {
-    $result = ($1_ltype)JCALL2(GetStringUTFChars, jenv, $input, 0);
-    if (!$result) return $null;
-  }
-}
-
-%typemap(directorin, descriptor="Ljava/lang/String;", noblock=1) char * {
- $input = 0;
-  if ($1) {
-    $input = JCALL1(NewStringUTF, jenv, (const char *)$1);
-    if (!$input) return $null;
-  }
-}
-
-%typemap(freearg, noblock=1) char * { if ($1) JCALL2(ReleaseStringUTFChars, jenv, $input, (const char *)$1); }
-%typemap(out, noblock=1) char * { if ($1) $result = JCALL1(NewStringUTF, jenv, (const char *)$1); }
-%typemap(javadirectorin) char * "$jniinput"
-%typemap(javadirectorout) char * "$javacall"
-
-/* char *& - treat as String */
-%typemap(in, noblock=1) char *& ($*1_ltype temp = 0) {
- $1 = 0;
-  if ($input) {
-    temp = ($*1_ltype)JCALL2(GetStringUTFChars, jenv, $input, 0);
-    if (!temp) return $null;
-  }
-  $1 = &temp;
-}
-%typemap(freearg, noblock=1) char *& { if ($1 && *$1) JCALL2(ReleaseStringUTFChars, jenv, $input, (const char *)*$1); }
-%typemap(out, noblock=1) char *& { if (*$1) $result = JCALL1(NewStringUTF, jenv, (const char *)*$1); }
-
-%typemap(out) void ""
-%typemap(javadirectorin) void "$jniinput"
-%typemap(javadirectorout) void "$javacall"
-%typemap(directorin, descriptor="V") void ""
-
-/* primitive types by 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(javadirectorin) const bool & "$jniinput"
-%typemap(javadirectorout) const bool & "$javacall"
-
-%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 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 float &,
-             const double &
-%{ static $*1_ltype temp;
-   temp = ($*1_ltype)$input; 
-   $result = &temp; %}
-
-%typemap(directorin, descriptor="Z") const bool &           "$input = (jboolean)$1;"
-%typemap(directorin, descriptor="C") const char &           "$input = (jchar)$1;"
-%typemap(directorin, descriptor="B") const signed char &    "$input = (jbyte)$1;"
-%typemap(directorin, descriptor="S") const unsigned char &  "$input = (jshort)$1;"
-%typemap(directorin, descriptor="S") const short &          "$input = (jshort)$1;"
-%typemap(directorin, descriptor="I") const unsigned short & "$input = (jint)$1;"
-%typemap(directorin, descriptor="I") const int &            "$input = (jint)$1;"
-%typemap(directorin, descriptor="J") const unsigned int &   "$input = (jlong)$1;"
-%typemap(directorin, descriptor="I") const long &           "$input = (jint)$1;"
-%typemap(directorin, descriptor="J") const unsigned long &  "$input = (jlong)$1;"
-%typemap(directorin, descriptor="J") const long long &      "$input = (jlong)$1;"
-%typemap(directorin, descriptor="F") const float &          "$input = (jfloat)$1;"
-%typemap(directorin, descriptor="D") const double &         "$input = (jdouble)$1;"
-
-%typemap(javadirectorin) 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 float & ($*1_ltype temp), 
-                         const double & ($*1_ltype temp)
-  "$jniinput"
-
-%typemap(javadirectorout) 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 float & ($*1_ltype temp), 
-                          const double & ($*1_ltype temp)
-  "$javacall"
-
-
-%typemap(out) const bool &           %{ $result = (jboolean)*$1; %}
-%typemap(out) const char &           %{ $result = (jchar)*$1; %}
-%typemap(out) const signed char &    %{ $result = (jbyte)*$1; %}
-%typemap(out) const unsigned char &  %{ $result = (jshort)*$1; %}
-%typemap(out) const short &          %{ $result = (jshort)*$1; %}
-%typemap(out) const unsigned short & %{ $result = (jint)*$1; %}
-%typemap(out) const int &            %{ $result = (jint)*$1; %}
-%typemap(out) const unsigned int &   %{ $result = (jlong)*$1; %}
-%typemap(out) const long &           %{ $result = (jint)*$1; %}
-%typemap(out) const unsigned long &  %{ $result = (jlong)*$1; %}
-%typemap(out) const long long &      %{ $result = (jlong)*$1; %}
-%typemap(out) const float &          %{ $result = (jfloat)*$1; %}
-%typemap(out) const double &         %{ $result = (jdouble)*$1; %}
-
-/* const unsigned long long & */
-/* Similar to unsigned long long */
-%typemap(in) const unsigned long long & ($*1_ltype temp) { 
-  jclass clazz;
-  jmethodID mid;
-  jbyteArray ba;
-  jbyte* bae;
-  jsize sz;
-  int i;
-
-  if (!$input) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
-    return $null;
-  }
-  clazz = JCALL1(GetObjectClass, jenv, $input);
-  mid = JCALL3(GetMethodID, jenv, clazz, "toByteArray", "()[B");
-  ba = (jbyteArray)JCALL2(CallObjectMethod, jenv, $input, mid);
-  bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
-  sz = JCALL1(GetArrayLength, jenv, ba);
-  $1 = &temp;
-  temp = 0;
-  for(i=0; i<sz; i++) {
-    temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
-  }
-  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
-}
-
-%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const unsigned long long & { 
-  static $*1_ltype temp;
-  jclass clazz;
-  jmethodID mid;
-  jbyteArray ba;
-  jbyte* bae;
-  jsize sz;
-  int i;
-
-  if (!$input) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
-    return $null;
-  }
-  clazz = JCALL1(GetObjectClass, jenv, $input);
-  mid = JCALL3(GetMethodID, jenv, clazz, "toByteArray", "()[B");
-  ba = (jbyteArray)JCALL2(CallObjectMethod, jenv, $input, mid);
-  bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
-  sz = JCALL1(GetArrayLength, jenv, ba);
-  $result = &temp;
-  temp = 0;
-  for(i=0; i<sz; i++) {
-    temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
-  }
-  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
-}
-
-%typemap(out) const unsigned long long & { 
-  jbyteArray ba = JCALL1(NewByteArray, jenv, 9);
-  jbyte* bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
-  jclass clazz = JCALL1(FindClass, jenv, "java/math/BigInteger");
-  jmethodID mid = JCALL3(GetMethodID, jenv, clazz, "<init>", "([B)V");
-  jobject bigint;
-  int i;
-
-  bae[0] = 0;
-  for(i=1; i<9; i++ ) {
-    bae[i] = (jbyte)(*$1>>8*(8-i));
-  }
-
-  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
-  bigint = JCALL3(NewObject, jenv, clazz, mid, ba);
-  $result = bigint;
-}
-
-%typemap(javadirectorin) const unsigned long long & "$jniinput"
-%typemap(javadirectorout) const unsigned long long & "$javacall"
-
-/* Default handling. Object passed by value. Convert to a pointer */
-%typemap(in) SWIGTYPE ($&1_type argp)
-%{ argp = *($&1_ltype*)&$input; 
-   if (!argp) {
-     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null $1_type");
-     return $null;
-   }
-   $1 = *argp; %}
-
-%typemap(directorout) SWIGTYPE ($&1_type argp)
-%{ argp = *($&1_ltype*)&$input; 
-   if (!argp) {
-     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Unexpected null return for type $1_type");
-     return $null;
-   }
-   $result = *argp; %}
-
-%typemap(out) SWIGTYPE 
-#ifdef __cplusplus
-%{ *($&1_ltype*)&$result = new $1_ltype((const $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,descriptor="L$packagepath/$&javaclassname;") SWIGTYPE 
-%{ $input = 0;
-   *(($&1_ltype*)&$input) = &$1; %}
-%typemap(javadirectorin) SWIGTYPE "new $&javaclassname($jniinput, false)"
-%typemap(javadirectorout) SWIGTYPE "$&javaclassname.getCPtr($javacall)"
-
-/* Generic pointers and references */
-%typemap(in) SWIGTYPE * %{ $1 = *($&1_ltype)&$input; %}
-%typemap(in, fragment="SWIG_UnPackData") SWIGTYPE (CLASS::*) { 
-  const char *temp = 0;
-  if ($input) {
-    temp = JCALL2(GetStringUTFChars, jenv, $input, 0);
-    if (!temp) return $null;
-  }
-  SWIG_UnpackData(temp, (void *)&$1, sizeof($1));
-}
-%typemap(in) SWIGTYPE & %{ $1 = *($&1_ltype)&$input;
-  if (!$1) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null");
-    return $null;
-  } %}
-%typemap(out) SWIGTYPE *
-%{ *($&1_ltype)&$result = $1; %} 
-%typemap(out, fragment="SWIG_PackData", noblock=1) SWIGTYPE (CLASS::*) {
-  char buf[128];
-  char *data = SWIG_PackData(buf, (void *)&$1, sizeof($1));
-  *data = '\0';
-  $result = JCALL1(NewStringUTF, jenv, buf);
-}
-%typemap(out) SWIGTYPE &
-%{ *($&1_ltype)&$result = $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,descriptor="L$packagepath/$javaclassname;") SWIGTYPE *
-%{ *(($&1_ltype)&$input) = ($1_ltype) $1; %}
-%typemap(directorin,descriptor="L$packagepath/$javaclassname;") SWIGTYPE (CLASS::*)
-%{ *(($&1_ltype)&$input) = ($1_ltype) $1; %}
-
-%typemap(directorout, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) SWIGTYPE &
-%{ if (!$input) {
-     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Unexpected null return for type $1_type");
-     return $null;
-   }
-   $result = *($&1_ltype)&$input; %}
-%typemap(directorin,descriptor="L$packagepath/$javaclassname;") SWIGTYPE &
-%{ *($&1_ltype)&$input = ($1_ltype) &$1; %}
-
-%typemap(javadirectorin) SWIGTYPE *, SWIGTYPE (CLASS::*) "($jniinput == 0) ? null : new $javaclassname($jniinput, false)"
-%typemap(javadirectorin) SWIGTYPE & "new $javaclassname($jniinput, false)"
-%typemap(javadirectorout) SWIGTYPE *, SWIGTYPE (CLASS::*), SWIGTYPE & "$javaclassname.getCPtr($javacall)"
-
-/* Default array handling */
-%typemap(in) SWIGTYPE [] %{ $1 = *($&1_ltype)&$input; %}
-%typemap(out) SWIGTYPE [] %{ *($&1_ltype)&$result = $1; %} 
-%typemap(freearg) SWIGTYPE [ANY], SWIGTYPE [] ""
-
-/* char arrays - treat as String */
-%typemap(in, noblock=1) char[ANY], char[] {
-  $1 = 0;
-  if ($input) {
-    $1 = ($1_ltype)JCALL2(GetStringUTFChars, jenv, $input, 0);
-    if (!$1) return $null;
-  }
-}
-
-%typemap(directorout, noblock=1) char[ANY], char[] {
-  $1 = 0;
-  if ($input) {
-    $result = ($1_ltype)JCALL2(GetStringUTFChars, jenv, $input, 0);
-    if (!$result) return $null;
-  }
-}
-
-%typemap(directorin, descriptor="Ljava/lang/String;", noblock=1) char[ANY], char[] {
-  $input = 0;
-  if ($1) {
-    $input = JCALL1(NewStringUTF, jenv, (const char *)$1);
-    if (!$input) return $null;
-  }
-}
-
-%typemap(argout) char[ANY], char[] ""
-%typemap(freearg, noblock=1) char[ANY], char[] { if ($1) JCALL2(ReleaseStringUTFChars, jenv, $input, (const char *)$1); }
-%typemap(out, noblock=1) char[ANY], char[] { if ($1) $result = JCALL1(NewStringUTF, jenv, (const char *)$1); }
-%typemap(javadirectorin) char[ANY], char[] "$jniinput"
-%typemap(javadirectorout) char[ANY], char[] "$javacall"
-
-/* JNI types */
-%typemap(in) jboolean,
-             jchar,
-             jbyte,
-             jshort,
-             jint,
-             jlong,
-             jfloat,
-             jdouble,
-             jstring,
-             jobject,
-             jbooleanArray,
-             jcharArray,
-             jbyteArray,
-             jshortArray,
-             jintArray,
-             jlongArray,
-             jfloatArray,
-             jdoubleArray,
-             jobjectArray
-%{ $1 = $input; %}
-
-%typemap(directorout) jboolean,
-             jchar,
-             jbyte,
-             jshort,
-             jint,
-             jlong,
-             jfloat,
-             jdouble,
-             jstring,
-             jobject,
-             jbooleanArray,
-             jcharArray,
-             jbyteArray,
-             jshortArray,
-             jintArray,
-             jlongArray,
-             jfloatArray,
-             jdoubleArray,
-             jobjectArray
-%{ $result = $input; %}
-
-%typemap(out) jboolean,
-              jchar,
-              jbyte,
-              jshort,
-              jint,
-              jlong,
-              jfloat,
-              jdouble,
-              jstring,
-              jobject,
-              jbooleanArray,
-              jcharArray,
-              jbyteArray,
-              jshortArray,
-              jintArray,
-              jlongArray,
-              jfloatArray,
-              jdoubleArray,
-              jobjectArray
-%{ $result = $1; %}
-
-%typemap(directorin,descriptor="Z")  jboolean       "$input = $1;"
-%typemap(directorin,descriptor="C")  jchar          "$input = $1;"
-%typemap(directorin,descriptor="B")  jbyte          "$input = $1;"
-%typemap(directorin,descriptor="S")  jshort         "$input = $1;"
-%typemap(directorin,descriptor="I")  jint           "$input = $1;"
-%typemap(directorin,descriptor="J")  jlong          "$input = $1;"
-%typemap(directorin,descriptor="F")  jfloat         "$input = $1;"
-%typemap(directorin,descriptor="D")  jdouble        "$input = $1;"
-%typemap(directorin,descriptor="Ljava/lang/String;")            jstring        "$input = $1;"
-%typemap(directorin,descriptor="Ljava/lang/Object;",nouse="1")  jobject        "$input = $1;"
-%typemap(directorin,descriptor="[Z")  jbooleanArray "$input = $1;"
-%typemap(directorin,descriptor="[C")  jcharArray    "$input = $1;"
-%typemap(directorin,descriptor="[B")  jbyteArray    "$input = $1;"
-%typemap(directorin,descriptor="[S")  jshortArray   "$input = $1;"
-%typemap(directorin,descriptor="[I")  jintArray     "$input = $1;"
-%typemap(directorin,descriptor="[J")  jlongArray    "$input = $1;"
-%typemap(directorin,descriptor="[F")  jfloatArray   "$input = $1;"
-%typemap(directorin,descriptor="[D")  jdoubleArray  "$input = $1;"
-%typemap(directorin,descriptor="[Ljava/lang/Object;",nouse="1") jobjectArray   "$input = $1;"
-
-%typemap(javadirectorin) jboolean,
-                         jchar,
-                         jbyte,
-                         jshort,
-                         jint,
-                         jlong,
-                         jfloat,
-                         jdouble,
-                         jstring,
-                         jobject,
-                         jbooleanArray,
-                         jcharArray,
-                         jbyteArray,
-                         jshortArray,
-                         jintArray,
-                         jlongArray,
-                         jfloatArray,
-                         jdoubleArray,
-                         jobjectArray
-  "$jniinput"
-
-%typemap(javadirectorout) jboolean,
-                          jchar,
-                          jbyte,
-                          jshort,
-                          jint,
-                          jlong,
-                          jfloat,
-                          jdouble,
-                          jstring,
-                          jobject,
-                          jbooleanArray,
-                          jcharArray,
-                          jbyteArray,
-                          jshortArray,
-                          jintArray,
-                          jlongArray,
-                          jfloatArray,
-                          jdoubleArray,
-                          jobjectArray
-  "$javacall"
-
-/* Typecheck typemaps - The purpose of these is merely to issue a warning for overloaded C++ functions 
- * that cannot be overloaded in Java as more than one C++ type maps to a single Java type */
-
-%typecheck(SWIG_TYPECHECK_BOOL) /* Java boolean */
-    jboolean,
-    bool,
-    const bool &
-    ""
-
-%typecheck(SWIG_TYPECHECK_CHAR) /* Java char */
-    jchar,
-    char, 
-    const char &
-    ""
-
-%typecheck(SWIG_TYPECHECK_INT8) /* Java byte */
-    jbyte,
-    signed char,
-    const signed char &
-    ""
-
-%typecheck(SWIG_TYPECHECK_INT16) /* Java short */
-    jshort,
-    unsigned char, 
-    short, 
-    const unsigned char &, 
-    const short &
-    ""
-
-%typecheck(SWIG_TYPECHECK_INT32) /* Java int */
-    jint,
-    unsigned short, 
-    int, 
-    long, 
-    const unsigned short &, 
-    const int &, 
-    const long &
-    ""
-
-%typecheck(SWIG_TYPECHECK_INT64) /* Java long */
-    jlong,
-    unsigned int, 
-    unsigned long, 
-    long long, 
-    const unsigned int &, 
-    const unsigned long &, 
-    const long long &
-    ""
-
-%typecheck(SWIG_TYPECHECK_INT128) /* Java BigInteger */
-    unsigned long long,
-    const unsigned long long &
-    ""
-
-%typecheck(SWIG_TYPECHECK_FLOAT) /* Java float */
-    jfloat,
-    float,
-    const float &
-    ""
-
-%typecheck(SWIG_TYPECHECK_DOUBLE) /* Java double */
-    jdouble,
-    double,
-    const double &
-    ""
-
-%typecheck(SWIG_TYPECHECK_STRING) /* Java String */
-    jstring,
-    char *,
-    char *&,
-    char[ANY],
-    char []
-    ""
-
-%typecheck(SWIG_TYPECHECK_BOOL_ARRAY) /* Java boolean[] */
-    jbooleanArray
-    ""
-
-%typecheck(SWIG_TYPECHECK_CHAR_ARRAY) /* Java char[] */
-    jcharArray
-    ""
-
-%typecheck(SWIG_TYPECHECK_INT8_ARRAY) /* Java byte[] */
-    jbyteArray
-    ""
-
-%typecheck(SWIG_TYPECHECK_INT16_ARRAY) /* Java short[] */
-    jshortArray
-    ""
-
-%typecheck(SWIG_TYPECHECK_INT32_ARRAY) /* Java int[] */
-    jintArray
-    ""
-
-%typecheck(SWIG_TYPECHECK_INT64_ARRAY) /* Java long[] */
-    jlongArray
-    ""
-
-%typecheck(SWIG_TYPECHECK_FLOAT_ARRAY) /* Java float[] */
-    jfloatArray
-    ""
-
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY) /* Java double[] */
-    jdoubleArray
-    ""
-
-%typecheck(SWIG_TYPECHECK_OBJECT_ARRAY) /* Java jobject[] */
-    jobjectArray
-    ""
-
-%typecheck(SWIG_TYPECHECK_POINTER) /* Default */
-    SWIGTYPE, 
-    SWIGTYPE *, 
-    SWIGTYPE &, 
-    SWIGTYPE *const&, 
-    SWIGTYPE [],
-    SWIGTYPE (CLASS::*)
-    ""
-
-
-/* Exception handling */
-
-%typemap(throws) 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_JavaThrowException(jenv, SWIG_JavaRuntimeException, error_msg);
-   return $null; %}
-
-%typemap(throws) SWIGTYPE, SWIGTYPE &, SWIGTYPE *, SWIGTYPE [], SWIGTYPE [ANY]
-%{ (void)$1;
-   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown");
-   return $null; %}
-
-%typemap(throws) char *
-%{ SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1);
-   return $null; %}
-
-
-/* Typemaps for code generation in proxy classes and Java type wrapper classes */
-
-/* The javain 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 JNI class. */
-%typemap(javain) 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 &
-    "$javainput"
-%typemap(javain) char *, char *&, char[ANY], char[] "$javainput"
-%typemap(javain) jboolean,
-                 jchar,
-                 jbyte,
-                 jshort,
-                 jint,
-                 jlong,
-                 jfloat,
-                 jdouble,
-                 jstring,
-                 jobject,
-                 jbooleanArray,
-                 jcharArray,
-                 jbyteArray,
-                 jshortArray,
-                 jintArray,
-                 jlongArray,
-                 jfloatArray,
-                 jdoubleArray,
-                 jobjectArray
-    "$javainput"
-%typemap(javain) SWIGTYPE "$&javaclassname.getCPtr($javainput)"
-%typemap(javain) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] "$javaclassname.getCPtr($javainput)"
-%typemap(javain) SWIGTYPE (CLASS::*) "$javaclassname.getCMemberPtr($javainput)"
-
-/* The javaout typemap is used for converting function return types from the return type
- * used in the JNI class to the type returned by the proxy, module or type wrapper class. */
-%typemap(javaout) 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 & {
-    return $jnicall;
-  }
-%typemap(javaout) char *, char *&, char[ANY], char[] {
-    return $jnicall;
-  }
-%typemap(javaout) jboolean,
-                  jchar,
-                  jbyte,
-                  jshort,
-                  jint,
-                  jlong,
-                  jfloat,
-                  jdouble,
-                  jstring,
-                  jobject,
-                  jbooleanArray,
-                  jcharArray,
-                  jbyteArray,
-                  jshortArray,
-                  jintArray,
-                  jlongArray,
-                  jfloatArray,
-                  jdoubleArray,
-                  jobjectArray {
-    return $jnicall;
-  }
-%typemap(javaout) void {
-    $jnicall;
-  }
-%typemap(javaout) SWIGTYPE {
-    return new $&javaclassname($jnicall, true);
-  }
-%typemap(javaout) SWIGTYPE & {
-    return new $javaclassname($jnicall, $owner);
-  }
-%typemap(javaout) SWIGTYPE *, SWIGTYPE [] {
-    long cPtr = $jnicall;
-    return (cPtr == 0) ? null : new $javaclassname(cPtr, $owner);
-  }
-%typemap(javaout) SWIGTYPE (CLASS::*) {
-    String cMemberPtr = $jnicall;
-    return (cMemberPtr == null) ? null : new $javaclassname(cMemberPtr, $owner);
-  }
-
-/* Pointer reference typemaps */
-%typemap(jni) SWIGTYPE *const& "jlong"
-%typemap(jtype) SWIGTYPE *const& "long"
-%typemap(jstype) SWIGTYPE *const& "$*javaclassname"
-%typemap(javain) SWIGTYPE *const& "$*javaclassname.getCPtr($javainput)"
-%typemap(javaout) SWIGTYPE *const& {
-    long cPtr = $jnicall;
-    return (cPtr == 0) ? null : new $*javaclassname(cPtr, $owner);
-  }
-%typemap(in) SWIGTYPE *const& ($*1_ltype temp = 0)
-%{ temp = *($1_ltype)&$input;
-   $1 = ($1_ltype)&temp; %}
-%typemap(out) SWIGTYPE *const&
-%{ *($1_ltype)&$result = *$1; %} 
-
-/* Typemaps used for the generation of proxy and type wrapper class code */
-%typemap(javabase)             SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
-%typemap(javaclassmodifiers)   SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) "public class"
-%typemap(javacode)             SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
-%typemap(javaimports)          SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
-%typemap(javainterfaces)       SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
-
-/* javabody typemaps */
-
-%define SWIG_JAVABODY_METHODS(PTRCTOR_VISIBILITY, CPTR_VISIBILITY, TYPE...) SWIG_JAVABODY_PROXY(PTRCTOR_VISIBILITY, CPTR_VISIBILITY, TYPE) %enddef // legacy name
-
-%define SWIG_JAVABODY_PROXY(PTRCTOR_VISIBILITY, CPTR_VISIBILITY, TYPE...)
-// Base proxy classes
-%typemap(javabody) TYPE %{
-  private long swigCPtr;
-  protected boolean swigCMemOwn;
-
-  PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = cPtr;
-  }
-
-  CPTR_VISIBILITY static long getCPtr($javaclassname obj) {
-    return (obj == null) ? 0 : obj.swigCPtr;
-  }
-%}
-
-// Derived proxy classes
-%typemap(javabody_derived) TYPE %{
-  private long swigCPtr;
-
-  PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
-    super($imclassname.$javaclazznameSWIGUpcast(cPtr), cMemoryOwn);
-    swigCPtr = cPtr;
-  }
-
-  CPTR_VISIBILITY static long getCPtr($javaclassname obj) {
-    return (obj == null) ? 0 : obj.swigCPtr;
-  }
-%}
-%enddef
-
-%define SWIG_JAVABODY_TYPEWRAPPER(PTRCTOR_VISIBILITY, DEFAULTCTOR_VISIBILITY, CPTR_VISIBILITY, TYPE...)
-// Typewrapper classes
-%typemap(javabody) TYPE *, TYPE &, TYPE [] %{
-  private long swigCPtr;
-
-  PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean futureUse) {
-    swigCPtr = cPtr;
-  }
-
-  DEFAULTCTOR_VISIBILITY $javaclassname() {
-    swigCPtr = 0;
-  }
-
-  CPTR_VISIBILITY static long getCPtr($javaclassname obj) {
-    return (obj == null) ? 0 : obj.swigCPtr;
-  }
-%}
-
-%typemap(javabody) TYPE (CLASS::*) %{
-  private String swigCMemberPtr;
-
-  PTRCTOR_VISIBILITY $javaclassname(String cMemberPtr, boolean futureUse) {
-    swigCMemberPtr = cMemberPtr;
-  }
-
-  DEFAULTCTOR_VISIBILITY $javaclassname() {
-    swigCMemberPtr = null;
-  }
-
-  CPTR_VISIBILITY static String getCMemberPtr($javaclassname obj) {
-    return obj.swigCMemberPtr;
-  }
-%}
-%enddef
-
-/* Set the default javabody typemaps to use protected visibility.
-   Use the macros to change to public if using multiple modules. */
-SWIG_JAVABODY_PROXY(protected, protected, SWIGTYPE)
-SWIG_JAVABODY_TYPEWRAPPER(protected, protected, protected, SWIGTYPE)
-
-%typemap(javafinalize) SWIGTYPE %{
-  protected void finalize() {
-    delete();
-  }
-%}
-
-/*
- * Java constructor typemaps:
- *
- * The javaconstruct typemap is inserted when a proxy class's constructor is generated.
- * This typemap allows control over what code is executed in the constructor as
- * well as specifying who owns the underlying C/C++ object. Normally, Java has
- * ownership and the underlying C/C++ object is deallocated when the Java object
- * is finalized (swigCMemOwn is true.) If swigCMemOwn is false, C/C++ is
- * ultimately responsible for deallocating the underlying object's memory.
- *
- * The SWIG_PROXY_CONSTRUCTOR macro defines the javaconstruct typemap for a proxy
- * class for a particular TYPENAME. OWNERSHIP is passed as the value of
- * swigCMemOwn to the pointer constructor method.  WEAKREF determines which kind
- * of Java object reference will be used by the C++ director class (WeakGlobalRef
- * vs. GlobalRef.)
- *
- * The SWIG_DIRECTOR_OWNED macro sets the ownership of director-based proxy
- * classes and the weak reference flag to false, meaning that the underlying C++
- * object will be reclaimed by C++.
- */
-
-%define SWIG_PROXY_CONSTRUCTOR(OWNERSHIP, WEAKREF, TYPENAME...)
-%typemap(javaconstruct,directorconnect="\n    $imclassname.$javaclazznamedirector_connect(this, swigCPtr, swigCMemOwn, WEAKREF);") TYPENAME {
-    this($imcall, OWNERSHIP);$directorconnect
-  }
-%enddef
-
-%define SWIG_DIRECTOR_OWNED(TYPENAME...)
-SWIG_PROXY_CONSTRUCTOR(true, false, TYPENAME)
-%enddef
-
-// Set the default for SWIGTYPE: Java owns the C/C++ object.
-SWIG_PROXY_CONSTRUCTOR(true, true, SWIGTYPE)
-
-%typemap(javadestruct, methodname="delete", methodmodifiers="public synchronized") SWIGTYPE {
-    if (swigCPtr != 0) {
-      if (swigCMemOwn) {
-        swigCMemOwn = false;
-        $jnicall;
-      }
-      swigCPtr = 0;
-    }
-  }
-
-%typemap(javadestruct_derived, methodname="delete", methodmodifiers="public synchronized") SWIGTYPE {
-    if (swigCPtr != 0) {
-      if (swigCMemOwn) {
-        swigCMemOwn = false;
-        $jnicall;
-      }
-      swigCPtr = 0;
-    }
-    super.delete();
-  }
-
-%typemap(directordisconnect, methodname="swigDirectorDisconnect") SWIGTYPE %{
-  protected void $methodname() {
-    swigCMemOwn = false;
-    $jnicall;
-  }
-%}
-
-%typemap(directorowner_release, methodname="swigReleaseOwnership") SWIGTYPE %{
-  public void $methodname() {
-    swigCMemOwn = false;
-    $jnicall;
-  }
-%}
-
-%typemap(directorowner_take, methodname="swigTakeOwnership") SWIGTYPE %{
-  public void $methodname() {
-    swigCMemOwn = true;
-    $jnicall;
-  }
-%}
-
-/* Java specific directives */
-#define %javaconst(flag)            %feature("java:const","flag")
-#define %javaconstvalue(value)      %feature("java:constvalue",value)
-#define %javaenum(wrapapproach)     %feature("java:enum","wrapapproach")
-#define %javamethodmodifiers        %feature("java:methodmodifiers")
-#define %javaexception(exceptionclasses) %feature("except",throws=exceptionclasses)
-#define %nojavaexception            %feature("except","0",throws="")
-#define %clearjavaexception         %feature("except","",throws="")
-
-%pragma(java) jniclassclassmodifiers="public class"
-%pragma(java) moduleclassmodifiers="public class"
-
-/* 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 }
-
-/* String & length */
-%typemap(jni)     (char *STRING, size_t LENGTH) "jbyteArray"
-%typemap(jtype)   (char *STRING, size_t LENGTH) "byte[]"
-%typemap(jstype)  (char *STRING, size_t LENGTH) "byte[]"
-%typemap(javain)  (char *STRING, size_t LENGTH) "$javainput"
-%typemap(freearg) (char *STRING, size_t LENGTH) ""
-%typemap(in)      (char *STRING, size_t LENGTH) {
-  if ($input) {
-    $1 = (char *) JCALL2(GetByteArrayElements, jenv, $input, 0);
-    $2 = (size_t) JCALL1(GetArrayLength, jenv, $input);
-  } else {
-    $1 = 0;
-    $2 = 0;
-  }
-}
-%typemap(argout)  (char *STRING, size_t LENGTH) {
-  if ($input) JCALL3(ReleaseByteArrayElements, jenv, $input, (jbyte *)$1, 0);
-}
-%typemap(directorin, descriptor="[B") (char *STRING, size_t LENGTH) {
-  jbyteArray jb = (jenv)->NewByteArray($2);
-  (jenv)->SetByteArrayRegion(jb, 0, $2, (jbyte *)$1);
-  $input = jb;
-}
-%typemap(directorargout) (char *STRING, size_t LENGTH)
-%{(jenv)->GetByteArrayRegion($input, 0, $2, (jbyte *)$1); %}
-%apply (char *STRING, size_t LENGTH) { (char *STRING, int LENGTH) }
-
-/* java keywords */
-%include <javakw.swg>
-
-// Default enum handling
-%include <enumtypesafe.swg>
-
diff --git a/share/swig/2.0.11/java/std_except.i b/share/swig/2.0.11/java/std_except.i
deleted file mode 100644
index 9e23d50..0000000
--- a/share/swig/2.0.11/java/std_except.i
+++ /dev/null
@@ -1,30 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.what());\n return $null;"
-%typemap(throws) std::domain_error      "SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.what());\n return $null;"
-%typemap(throws) std::exception         "SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.what());\n return $null;"
-%typemap(throws) std::invalid_argument  "SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, $1.what());\n return $null;"
-%typemap(throws) std::length_error      "SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, $1.what());\n return $null;"
-%typemap(throws) std::logic_error       "SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.what());\n return $null;"
-%typemap(throws) std::out_of_range      "SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, $1.what());\n return $null;"
-%typemap(throws) std::overflow_error    "SWIG_JavaThrowException(jenv, SWIG_JavaArithmeticException, $1.what());\n return $null;"
-%typemap(throws) std::range_error       "SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, $1.what());\n return $null;"
-%typemap(throws) std::runtime_error     "SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.what());\n return $null;"
-%typemap(throws) std::underflow_error   "SWIG_JavaThrowException(jenv, SWIG_JavaArithmeticException, $1.what());\n return $null;"
-
diff --git a/share/swig/2.0.11/java/std_string.i b/share/swig/2.0.11/java/std_string.i
deleted file mode 100644
index f178e6d..0000000
--- a/share/swig/2.0.11/java/std_string.i
+++ /dev/null
@@ -1,117 +0,0 @@
-/* -----------------------------------------------------------------------------
- * std_string.i
- *
- * Typemaps for std::string and const std::string&
- * These are mapped to a Java 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(jni) string "jstring"
-%typemap(jtype) string "String"
-%typemap(jstype) string "String"
-%typemap(javadirectorin) string "$jniinput"
-%typemap(javadirectorout) string "$javacall"
-
-%typemap(in) string 
-%{ if(!$input) {
-     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
-     return $null;
-    } 
-    const char *$1_pstr = (const char *)jenv->GetStringUTFChars($input, 0); 
-    if (!$1_pstr) return $null;
-    $1.assign($1_pstr);
-    jenv->ReleaseStringUTFChars($input, $1_pstr); %}
-
-%typemap(directorout) string 
-%{ if(!$input) {
-     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
-     return $null;
-   } 
-   const char *$1_pstr = (const char *)jenv->GetStringUTFChars($input, 0); 
-   if (!$1_pstr) return $null;
-   $result.assign($1_pstr);
-   jenv->ReleaseStringUTFChars($input, $1_pstr); %}
-
-%typemap(directorin,descriptor="Ljava/lang/String;") string 
-%{ $input = jenv->NewStringUTF($1.c_str()); %}
-
-%typemap(out) string 
-%{ $result = jenv->NewStringUTF($1.c_str()); %}
-
-%typemap(javain) string "$javainput"
-
-%typemap(javaout) string {
-    return $jnicall;
-  }
-
-%typemap(typecheck) string = char *;
-
-%typemap(throws) string
-%{ SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.c_str());
-   return $null; %}
-
-// const string &
-%typemap(jni) const string & "jstring"
-%typemap(jtype) const string & "String"
-%typemap(jstype) const string & "String"
-%typemap(javadirectorin) const string & "$jniinput"
-%typemap(javadirectorout) const string & "$javacall"
-
-%typemap(in) const string &
-%{ if(!$input) {
-     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
-     return $null;
-   }
-   const char *$1_pstr = (const char *)jenv->GetStringUTFChars($input, 0); 
-   if (!$1_pstr) return $null;
-   $*1_ltype $1_str($1_pstr);
-   $1 = &$1_str;
-   jenv->ReleaseStringUTFChars($input, $1_pstr); %}
-
-%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const string &
-%{ if(!$input) {
-     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
-     return $null;
-   }
-   const char *$1_pstr = (const char *)jenv->GetStringUTFChars($input, 0); 
-   if (!$1_pstr) return $null;
-   /* possible thread/reentrant code problem */
-   static $*1_ltype $1_str;
-   $1_str = $1_pstr;
-   $result = &$1_str;
-   jenv->ReleaseStringUTFChars($input, $1_pstr); %}
-
-%typemap(directorin,descriptor="Ljava/lang/String;") const string &
-%{ $input = jenv->NewStringUTF($1.c_str()); %}
-
-%typemap(out) const string & 
-%{ $result = jenv->NewStringUTF($1->c_str()); %}
-
-%typemap(javain) const string & "$javainput"
-
-%typemap(javaout) const string & {
-    return $jnicall;
-  }
-
-%typemap(typecheck) const string & = char *;
-
-%typemap(throws) const string &
-%{ SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.c_str());
-   return $null; %}
-
-}
-
diff --git a/share/swig/2.0.11/java/std_vector.i b/share/swig/2.0.11/java/std_vector.i
deleted file mode 100644
index 3f29b19..0000000
--- a/share/swig/2.0.11/java/std_vector.i
+++ /dev/null
@@ -1,85 +0,0 @@
-/* -----------------------------------------------------------------------------
- * std_vector.i
- * ----------------------------------------------------------------------------- */
-
-%include <std_common.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");
-            }
-        }
-    };
-}
-
-%define specialize_std_vector(T)
-#warning "specialize_std_vector - specialization for type T no longer needed"
-%enddef
-
diff --git a/share/swig/2.0.11/java/std_wstring.i b/share/swig/2.0.11/java/std_wstring.i
deleted file mode 100644
index 12d8fc1..0000000
--- a/share/swig/2.0.11/java/std_wstring.i
+++ /dev/null
@@ -1,172 +0,0 @@
-/* -----------------------------------------------------------------------------
- * std_wstring.i
- *
- * Typemaps for std::wstring and const std::wstring&
- *
- * These are mapped to a Java String and are passed around by value.
- * Warning: Unicode / multibyte characters are handled differently on different 
- * OSs so the std::wstring typemaps may not always work as intended.
- *
- * To use non-const std::wstring references use the following %apply.  Note 
- * that they are passed by value.
- * %apply const std::wstring & {std::wstring &};
- * ----------------------------------------------------------------------------- */
-
-namespace std {
-
-%naturalvar wstring;
-
-class wstring;
-
-// wstring
-%typemap(jni) wstring "jstring"
-%typemap(jtype) wstring "String"
-%typemap(jstype) wstring "String"
-%typemap(javadirectorin) wstring "$jniinput"
-%typemap(javadirectorout) wstring "$javacall"
-
-%typemap(in) wstring
-%{if(!$input) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null std::wstring");
-    return $null;
-  }
-  const jchar *$1_pstr = jenv->GetStringChars($input, 0);
-  if (!$1_pstr) return $null;
-  jsize $1_len = jenv->GetStringLength($input);
-  if ($1_len) {
-    $1.reserve($1_len);
-    for (jsize i = 0; i < $1_len; ++i) {
-      $1.push_back((wchar_t)$1_pstr[i]);
-    }
-  }
-  jenv->ReleaseStringChars($input, $1_pstr);
- %}
-
-%typemap(directorout) wstring
-%{if(!$input) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null std::wstring");
-    return $null;
-  }
-  const jchar *$1_pstr = jenv->GetStringChars($input, 0);
-  if (!$1_pstr) return $null;
-  jsize $1_len = jenv->GetStringLength($input);
-  if ($1_len) {
-    $result.reserve($1_len);
-    for (jsize i = 0; i < $1_len; ++i) {
-      $result.push_back((wchar_t)$1_pstr[i]);
-    }
-  }
-  jenv->ReleaseStringChars($input, $1_pstr);
- %}
-
-%typemap(directorin,descriptor="Ljava/lang/String;") wstring {
-  jsize $1_len = $1.length();
-  jchar *conv_buf = new jchar[$1_len];
-  for (jsize i = 0; i < $1_len; ++i) {
-    conv_buf[i] = (jchar)$1[i];
-  }
-  $input = jenv->NewString(conv_buf, $1_len);
-  delete [] conv_buf;
-}
-
-%typemap(out) wstring
-%{jsize $1_len = $1.length();
-  jchar *conv_buf = new jchar[$1_len];
-  for (jsize i = 0; i < $1_len; ++i) {
-    conv_buf[i] = (jchar)$1[i];
-  }
-  $result = jenv->NewString(conv_buf, $1_len);
-  delete [] conv_buf; %}
-
-%typemap(javain) wstring "$javainput"
-
-%typemap(javaout) wstring {
-    return $jnicall;
-  }
-
-//%typemap(typecheck) wstring = wchar_t *;
-
-%typemap(throws) wstring
-%{ std::string message($1.begin(), $1.end());
-   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, message.c_str());
-   return $null; %}
-
-// const wstring &
-%typemap(jni) const wstring & "jstring"
-%typemap(jtype) const wstring & "String"
-%typemap(jstype) const wstring & "String"
-%typemap(javadirectorin) const wstring & "$jniinput"
-%typemap(javadirectorout) const wstring & "$javacall"
-
-%typemap(in) const wstring &
-%{if(!$input) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null std::wstring");
-    return $null;
-  }
-  const jchar *$1_pstr = jenv->GetStringChars($input, 0);
-  if (!$1_pstr) return $null;
-  jsize $1_len = jenv->GetStringLength($input);
-  std::wstring $1_str;
-  if ($1_len) {
-    $1_str.reserve($1_len);
-    for (jsize i = 0; i < $1_len; ++i) {
-      $1_str.push_back((wchar_t)$1_pstr[i]);
-    }
-  }
-  $1 = &$1_str;
-  jenv->ReleaseStringChars($input, $1_pstr);
- %}
-
-%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const wstring & 
-%{if(!$input) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null std::wstring");
-    return $null;
-  }
-  const jchar *$1_pstr = jenv->GetStringChars($input, 0);
-  if (!$1_pstr) return $null;
-  jsize $1_len = jenv->GetStringLength($input);
-  /* possible thread/reentrant code problem */
-  static std::wstring $1_str;
-  if ($1_len) {
-    $1_str.reserve($1_len);
-    for (jsize i = 0; i < $1_len; ++i) {
-      $1_str.push_back((wchar_t)$1_pstr[i]);
-    }
-  }
-  $result = &$1_str;
-  jenv->ReleaseStringChars($input, $1_pstr); %}
-
-%typemap(directorin,descriptor="Ljava/lang/String;") const wstring & {
-  jsize $1_len = $1.length();
-  jchar *conv_buf = new jchar[$1_len];
-  for (jsize i = 0; i < $1_len; ++i) {
-    conv_buf[i] = (jchar)($1)[i];
-  }
-  $input = jenv->NewString(conv_buf, $1_len);
-  delete [] conv_buf;
-}
-
-%typemap(out) const wstring & 
-%{jsize $1_len = $1->length();
-  jchar *conv_buf = new jchar[$1_len];
-  for (jsize i = 0; i < $1_len; ++i) {
-    conv_buf[i] = (jchar)(*$1)[i];
-  }
-  $result = jenv->NewString(conv_buf, $1_len);
-  delete [] conv_buf; %}
-
-%typemap(javain) const wstring & "$javainput"
-
-%typemap(javaout) const wstring & {
-    return $jnicall;
-  }
-
-//%typemap(typecheck) const wstring & = wchar_t *;
-
-%typemap(throws) const wstring &
-%{ std::string message($1.begin(), $1.end());
-   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, message.c_str());
-   return $null; %}
-
-}
-
diff --git a/share/swig/2.0.11/java/typemaps.i b/share/swig/2.0.11/java/typemaps.i
deleted file mode 100644
index e71790b..0000000
--- a/share/swig/2.0.11/java/typemaps.i
+++ /dev/null
@@ -1,427 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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 Java you could then use it like this:
-        double 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, JNITYPE, JTYPE, JNIDESC)
-%typemap(jni) TYPE *INPUT, TYPE &INPUT "JNITYPE"
-%typemap(jtype) TYPE *INPUT, TYPE &INPUT "JTYPE"
-%typemap(jstype) TYPE *INPUT, TYPE &INPUT "JTYPE"
-%typemap(javain) TYPE *INPUT, TYPE &INPUT "$javainput"
-
-%typemap(in) TYPE *INPUT, TYPE &INPUT
-%{ $1 = ($1_ltype)&$input; %}
-
-%typemap(freearg) TYPE *INPUT, TYPE &INPUT ""
-
-%typemap(typecheck) TYPE *INPUT = TYPE;
-%typemap(typecheck) TYPE &INPUT = TYPE;
-%enddef
-
-INPUT_TYPEMAP(bool, jboolean, boolean, "Z");
-INPUT_TYPEMAP(signed char, jbyte, byte, "B");
-INPUT_TYPEMAP(unsigned char, jshort, short, "S");
-INPUT_TYPEMAP(short, jshort, short, "S");
-INPUT_TYPEMAP(unsigned short, jint, int, "I");
-INPUT_TYPEMAP(int, jint, int, "I");
-INPUT_TYPEMAP(unsigned int, jlong, long, "J");
-INPUT_TYPEMAP(long, jint, int, "I");
-INPUT_TYPEMAP(unsigned long, jlong, long, "J");
-INPUT_TYPEMAP(long long, jlong, long, "J");
-INPUT_TYPEMAP(unsigned long long, jobject, java.math.BigInteger, "Ljava/math/BigInteger;");
-INPUT_TYPEMAP(float, jfloat, float, "F");
-INPUT_TYPEMAP(double, jdouble, double, "D");
-
-#undef INPUT_TYPEMAP
-
-/* Convert from BigInteger using the toByteArray member function */
-/* Overrides the typemap in the INPUT_TYPEMAP macro */
-%typemap(in) unsigned long long *INPUT($*1_ltype temp), unsigned long long &INPUT($*1_ltype temp) {
-  jclass clazz;
-  jmethodID mid;
-  jbyteArray ba;
-  jbyte* bae;
-  jsize sz;
-  int i;
-
-  if (!$input) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
-    return $null;
-  }
-  clazz = JCALL1(GetObjectClass, jenv, $input);
-  mid = JCALL3(GetMethodID, jenv, clazz, "toByteArray", "()[B");
-  ba = (jbyteArray)JCALL2(CallObjectMethod, jenv, $input, mid);
-  bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
-  sz = JCALL1(GetArrayLength, jenv, ba);
-  temp = 0;
-  for(i=0; i<sz; i++) {
-    temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
-  }
-  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
-  $1 = &temp;
-}
-
-// 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 
-Java array being passed as a parameter where a c pointer or reference is required. 
-As with any Java 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 Java output of the function would be the function return value and the 
-value in the single element array. In Java you would use it like this:
-
-    double[] ptr = {0.0};
-    double 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);
-*/
-
-/* Java BigInteger[] */
-%typecheck(SWIG_TYPECHECK_INT128_ARRAY) SWIGBIGINTEGERARRAY ""
-
-%define OUTPUT_TYPEMAP(TYPE, JNITYPE, JTYPE, JAVATYPE, JNIDESC, TYPECHECKTYPE)
-%typemap(jni) TYPE *OUTPUT, TYPE &OUTPUT %{JNITYPE##Array%}
-%typemap(jtype) TYPE *OUTPUT, TYPE &OUTPUT "JTYPE[]"
-%typemap(jstype) TYPE *OUTPUT, TYPE &OUTPUT "JTYPE[]"
-%typemap(javain) TYPE *OUTPUT, TYPE &OUTPUT "$javainput"
-
-%typemap(in) TYPE *OUTPUT($*1_ltype temp), TYPE &OUTPUT($*1_ltype temp)
-{
-  if (!$input) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
-    return $null;
-  }
-  if (JCALL1(GetArrayLength, jenv, $input) == 0) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
-    return $null;
-  }
-  temp = ($*1_ltype)0;
-  $1 = &temp; 
-}
-
-%typemap(freearg) TYPE *OUTPUT, TYPE &OUTPUT ""
-
-%typemap(argout) TYPE *OUTPUT, TYPE &OUTPUT 
-{
-  JNITYPE jvalue = (JNITYPE)temp$argnum;
-  JCALL4(Set##JAVATYPE##ArrayRegion, jenv, $input, 0, 1, &jvalue);
-}
-
-%typemap(typecheck) TYPE *OUTPUT = TYPECHECKTYPE;
-%typemap(typecheck) TYPE &OUTPUT = TYPECHECKTYPE;
-%enddef
-
-OUTPUT_TYPEMAP(bool, jboolean, boolean, Boolean, "[Ljava/lang/Boolean;", jbooleanArray);
-OUTPUT_TYPEMAP(signed char, jbyte, byte, Byte, "[Ljava/lang/Byte;", jbyteArray);               
-OUTPUT_TYPEMAP(unsigned char, jshort, short, Short, "[Ljava/lang/Short;", jshortArray);              
-OUTPUT_TYPEMAP(short, jshort, short, Short, "[Ljava/lang/Short;", jshortArray);              
-OUTPUT_TYPEMAP(unsigned short, jint, int, Int, "[Ljava/lang/Integer;", jintArray);                
-OUTPUT_TYPEMAP(int, jint, int, Int, "[Ljava/lang/Integer;", jintArray);                
-OUTPUT_TYPEMAP(unsigned int, jlong, long, Long, "[Ljava/lang/Long;", jlongArray);               
-OUTPUT_TYPEMAP(long, jint, int, Int, "[Ljava/lang/Integer;", jintArray);                
-OUTPUT_TYPEMAP(unsigned long, jlong, long, Long, "[Ljava/lang/Long;", jlongArray);               
-OUTPUT_TYPEMAP(long long, jlong, long, Long, "[Ljava/lang/Long;", jlongArray);               
-OUTPUT_TYPEMAP(unsigned long long, jobject, java.math.BigInteger, NOTUSED, "[Ljava/lang/BigInteger;", SWIGBIGINTEGERARRAY);
-OUTPUT_TYPEMAP(float, jfloat, float, Float, "[Ljava/lang/Float;", jfloatArray);              
-OUTPUT_TYPEMAP(double, jdouble, double, Double, "[Ljava/lang/Double;", jdoubleArray);             
-
-#undef OUTPUT_TYPEMAP
-
-%typemap(in) bool *OUTPUT($*1_ltype temp), bool &OUTPUT($*1_ltype temp)
-{
-  if (!$input) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
-    return $null;
-  }
-  if (JCALL1(GetArrayLength, jenv, $input) == 0) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
-    return $null;
-  }
-  temp = false;
-  $1 = &temp; 
-}
-
-/* Convert to BigInteger - byte array holds number in 2's complement big endian format */
-/* Use first element in BigInteger array for output */
-/* Overrides the typemap in the OUTPUT_TYPEMAP macro */
-%typemap(argout) unsigned long long *OUTPUT, unsigned long long &OUTPUT { 
-  jbyteArray ba = JCALL1(NewByteArray, jenv, 9);
-  jbyte* bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
-  jclass clazz = JCALL1(FindClass, jenv, "java/math/BigInteger");
-  jmethodID mid = JCALL3(GetMethodID, jenv, clazz, "<init>", "([B)V");
-  jobject bigint;
-  int i;
-
-  bae[0] = 0;
-  for(i=1; i<9; i++ ) {
-    bae[i] = (jbyte)(temp$argnum>>8*(8-i));
-  }
-
-  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
-  bigint = JCALL3(NewObject, jenv, clazz, mid, ba);
-  JCALL3(SetObjectArrayElement, jenv, $input, 0, bigint);
-}
-
-/*
-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 Java array.
-
-        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.
-
-       double x[] = {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 Java 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, JNITYPE, JTYPE, JAVATYPE, JNIDESC, TYPECHECKTYPE)
-%typemap(jni) TYPE *INOUT, TYPE &INOUT %{JNITYPE##Array%}
-%typemap(jtype) TYPE *INOUT, TYPE &INOUT "JTYPE[]"
-%typemap(jstype) TYPE *INOUT, TYPE &INOUT "JTYPE[]"
-%typemap(javain) TYPE *INOUT, TYPE &INOUT "$javainput"
-
-%typemap(in) TYPE *INOUT, TYPE &INOUT {
-  if (!$input) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
-    return $null;
-  }
-  if (JCALL1(GetArrayLength, jenv, $input) == 0) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
-    return $null;
-  }
-  $1 = ($1_ltype) JCALL2(Get##JAVATYPE##ArrayElements, jenv, $input, 0); 
-}
-
-%typemap(freearg) TYPE *INOUT, TYPE &INOUT ""
-
-%typemap(argout) TYPE *INOUT, TYPE &INOUT
-{ JCALL3(Release##JAVATYPE##ArrayElements, jenv, $input, (JNITYPE *)$1, 0); }
-
-
-%typemap(typecheck) TYPE *INOUT = TYPECHECKTYPE;
-%typemap(typecheck) TYPE &INOUT = TYPECHECKTYPE;
-%enddef
-
-INOUT_TYPEMAP(bool, jboolean, boolean, Boolean, "[Ljava/lang/Boolean;", jbooleanArray); 
-INOUT_TYPEMAP(signed char, jbyte, byte, Byte, "[Ljava/lang/Byte;", jbyteArray); 
-INOUT_TYPEMAP(unsigned char, jshort, short, Short, "[Ljava/lang/Short;", jshortArray);     
-INOUT_TYPEMAP(short, jshort, short, Short, "[Ljava/lang/Short;", jshortArray);
-INOUT_TYPEMAP(unsigned short, jint, int, Int, "[Ljava/lang/Integer;", jintArray); 
-INOUT_TYPEMAP(int, jint, int, Int, "[Ljava/lang/Integer;", jintArray);
-INOUT_TYPEMAP(unsigned int, jlong, long, Long, "[Ljava/lang/Long;", jlongArray); 
-INOUT_TYPEMAP(long, jint, int, Int, "[Ljava/lang/Integer;", jintArray);
-INOUT_TYPEMAP(unsigned long, jlong, long, Long, "[Ljava/lang/Long;", jlongArray); 
-INOUT_TYPEMAP(long long, jlong, long, Long, "[Ljava/lang/Long;", jlongArray);
-INOUT_TYPEMAP(unsigned long long, jobject, java.math.BigInteger, NOTUSED, "[Ljava.math.BigInteger;", SWIGBIGINTEGERARRAY);
-INOUT_TYPEMAP(float, jfloat, float, Float, "[Ljava/lang/Float;", jfloatArray);
-INOUT_TYPEMAP(double, jdouble, double, Double, "[Ljava/lang/Double;", jdoubleArray); 
-
-#undef INOUT_TYPEMAP
-
-/* Override typemaps in the INOUT_TYPEMAP macro for booleans to fix casts
-   as a jboolean isn't always the same size as a bool */
-%typemap(in) bool *INOUT (bool btemp, jboolean *jbtemp), bool &INOUT (bool btemp, jboolean *jbtemp) {
-  if (!$input) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
-    return $null;
-  }
-  if (JCALL1(GetArrayLength, jenv, $input) == 0) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
-    return $null;
-  }
-  jbtemp = JCALL2(GetBooleanArrayElements, jenv, $input, 0);
-  btemp = (*jbtemp) ? true : false;
-  $1 = &btemp;
-}
-
-%typemap(argout) bool *INOUT, bool &INOUT {
-  *jbtemp$argnum = btemp$argnum ? (jboolean)1 : (jboolean)0;
-  JCALL3(ReleaseBooleanArrayElements, jenv, $input , (jboolean *)jbtemp$argnum, 0);
-}
-
-/* Override the typemap in the INOUT_TYPEMAP macro for unsigned long long */
-%typemap(in) unsigned long long *INOUT ($*1_ltype temp), unsigned long long &INOUT ($*1_ltype temp) { 
-  jobject bigint;
-  jclass clazz;
-  jmethodID mid;
-  jbyteArray ba;
-  jbyte* bae;
-  jsize sz;
-  int i;
-
-  if (!$input) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
-    return $null;
-  }
-  if (JCALL1(GetArrayLength, jenv, $input) == 0) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
-    return $null;
-  }
-  bigint = JCALL2(GetObjectArrayElement, jenv, $input, 0);
-  if (!bigint) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array element null");
-    return $null;
-  }
-  clazz = JCALL1(GetObjectClass, jenv, bigint);
-  mid = JCALL3(GetMethodID, jenv, clazz, "toByteArray", "()[B");
-  ba = (jbyteArray)JCALL2(CallObjectMethod, jenv, bigint, mid);
-  bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
-  sz = JCALL1(GetArrayLength, jenv, ba);
-  temp = 0;
-  for(i=0; i<sz; i++) {
-    temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
-  }
-  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
-  $1 = &temp;
-}
-
-%typemap(argout) unsigned long long *INOUT = unsigned long long *OUTPUT;
-%typemap(argout) unsigned long long &INOUT = unsigned long long &OUTPUT;
diff --git a/share/swig/2.0.11/java/various.i b/share/swig/2.0.11/java/various.i
deleted file mode 100644
index f589bf7..0000000
--- a/share/swig/2.0.11/java/various.i
+++ /dev/null
@@ -1,156 +0,0 @@
-/* -----------------------------------------------------------------------------
- * various.i
- *
- * SWIG Typemap library for Java.
- * Various useful typemaps.
- * ----------------------------------------------------------------------------- */
-
-/* 
- * char **STRING_ARRAY typemaps. 
- * These typemaps are for C String arrays which are NULL terminated.
- *   char *values[] = { "one", "two", "three", NULL }; // note NULL
- * char ** is mapped to a Java String[].
- *
- * Example usage wrapping:
- *   %apply char **STRING_ARRAY { char **input };
- *   char ** foo(char **input);
- *  
- * Java usage:
- *   String numbers[] = { "one", "two", "three" };
- *   String[] ret = modulename.foo( numbers };
- */
-%typemap(jni) char **STRING_ARRAY "jobjectArray"
-%typemap(jtype) char **STRING_ARRAY "String[]"
-%typemap(jstype) char **STRING_ARRAY "String[]"
-%typemap(in) char **STRING_ARRAY (jint size) {
-  int i = 0;
-  if ($input) {
-    size = JCALL1(GetArrayLength, jenv, $input);
-#ifdef __cplusplus
-    $1 = new char*[size+1];
-#else
-    $1 = (char **)calloc(size+1, sizeof(char *));
-#endif
-    for (i = 0; i<size; i++) {
-      jstring j_string = (jstring)JCALL2(GetObjectArrayElement, jenv, $input, i);
-      const char *c_string = JCALL2(GetStringUTFChars, jenv, j_string, 0);
-#ifdef __cplusplus
-      $1[i] = new char [strlen(c_string)+1];
-#else
-      $1[i] = (char *)calloc(strlen(c_string)+1, sizeof(const char *));
-#endif
-      strcpy($1[i], c_string);
-      JCALL2(ReleaseStringUTFChars, jenv, j_string, c_string);
-      JCALL1(DeleteLocalRef, jenv, j_string);
-    }
-    $1[i] = 0;
-  } else {
-    $1 = 0;
-    size = 0;
-  }
-}
-
-%typemap(freearg) char **STRING_ARRAY {
-  int i;
-  for (i=0; i<size$argnum-1; i++)
-#ifdef __cplusplus
-    delete[] $1[i];
-  delete[] $1;
-#else
-  free($1[i]);
-  free($1);
-#endif
-}
-
-%typemap(out) char **STRING_ARRAY {
-  if ($1) {
-    int i;
-    int len=0;
-    jstring temp_string;
-    const jclass clazz = JCALL1(FindClass, jenv, "java/lang/String");
-
-    while ($1[len]) len++;
-    $result = JCALL3(NewObjectArray, jenv, len, clazz, NULL);
-    /* exception checking omitted */
-
-    for (i=0; i<len; i++) {
-      temp_string = JCALL1(NewStringUTF, jenv, *$1++);
-      JCALL3(SetObjectArrayElement, jenv, $result, i, temp_string);
-      JCALL1(DeleteLocalRef, jenv, temp_string);
-    }
-  }
-}
-
-%typemap(javain) char **STRING_ARRAY "$javainput"
-%typemap(javaout) char **STRING_ARRAY {
-    return $jnicall;
-  }
-
-/* 
- * char **STRING_OUT typemaps. 
- * These are typemaps for returning strings when using a C char ** parameter type.
- * The returned string appears in the 1st element of the passed in Java String array.
- *
- * Example usage wrapping:
- *   void foo(char **string_out);
- *  
- * Java usage:
- *   String stringOutArray[] = { "" };
- *   modulename.foo(stringOutArray);
- *   System.out.println( stringOutArray[0] );
- */
-%typemap(jni) char **STRING_OUT "jobjectArray"
-%typemap(jtype) char **STRING_OUT "String[]"
-%typemap(jstype) char **STRING_OUT "String[]"
-%typemap(javain) char **STRING_OUT "$javainput"
-
-%typemap(in) char **STRING_OUT($*1_ltype temp) {
-  if (!$input) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
-    return $null;
-  }
-  if (JCALL1(GetArrayLength, jenv, $input) == 0) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
-    return $null;
-  }
-  $1 = &temp; 
-  *$1 = 0;
-}
-
-%typemap(argout) char **STRING_OUT {
-  jstring jnewstring = NULL;
-  if ($1) {
-     jnewstring = JCALL1(NewStringUTF, jenv, *$1);
-  }
-  JCALL3(SetObjectArrayElement, jenv, $input, 0, jnewstring); 
-}
-
-/* 
- * char *BYTE typemaps. 
- * These are input typemaps for mapping a Java byte[] array to a C char array.
- * Note that as a Java array is used and thus passeed by reference, the C routine 
- * can return data to Java via the parameter.
- *
- * Example usage wrapping:
- *   void foo(char *array);
- *  
- * Java usage:
- *   byte b[] = new byte[20];
- *   modulename.foo(b);
- */
-%typemap(jni) char *BYTE "jbyteArray"
-%typemap(jtype) char *BYTE "byte[]"
-%typemap(jstype) char *BYTE "byte[]"
-%typemap(in) char *BYTE {
-  $1 = (char *) JCALL2(GetByteArrayElements, jenv, $input, 0); 
-}
-
-%typemap(argout) char *BYTE {
-  JCALL3(ReleaseByteArrayElements, jenv, $input, (jbyte *) $1, 0); 
-}
-
-%typemap(javain) char *BYTE "$javainput"
-
-/* Prevent default freearg typemap from being used */
-%typemap(freearg) char *BYTE ""
-
diff --git a/share/swig/2.0.11/lua/lua.swg b/share/swig/2.0.11/lua/lua.swg
deleted file mode 100644
index d3b3351..0000000
--- a/share/swig/2.0.11/lua/lua.swg
+++ /dev/null
@@ -1,232 +0,0 @@
-/* -----------------------------------------------------------------------------
- * lua.swg
- *
- * SWIG Configuration File for Lua.
- * This file is parsed by SWIG before reading any other interface file.
- * ----------------------------------------------------------------------------- */
-
-/* -----------------------------------------------------------------------------
- *                          includes
- * ----------------------------------------------------------------------------- */
-
-%include <luatypemaps.swg>          /* The typemaps */
-%include <luaruntime.swg>          /* The runtime stuff */
-
-//%include <typemaps/swigmacros.swg>
-/* -----------------------------------------------------------------------------
- *                          constants typemaps
- * ----------------------------------------------------------------------------- */
-// this basically adds to a table of constants
-%typemap(consttab) int, unsigned int, short, unsigned short, long, unsigned long, unsigned char, signed char, bool, enum SWIGTYPE
-       {SWIG_LUA_CONSTTAB_INT("$symname", $value)}
-
-%typemap(consttab) float, double
-       {SWIG_LUA_CONSTTAB_FLOAT("$symname", $value)}
-
-%typemap(consttab) long long, unsigned long long, signed long long
-       {SWIG_LUA_CONSTTAB_FLOAT("$symname", $value)}
-
-%typemap(consttab) const long long&, const unsigned long long&, const signed long long&
-       {SWIG_LUA_CONSTTAB_FLOAT("$symname", *$value)}
-
-%typemap(consttab) char *, const char *, char [], const char []
-       {SWIG_LUA_CONSTTAB_STRING("$symname", $value)}
-
-// note: char is treated as a seperate special type
-// signed char & unsigned char are numbers
-%typemap(consttab) char
-       {SWIG_LUA_CONSTTAB_CHAR("$symname", $value)}
-
-%typemap(consttab) long long, unsigned long long
-       {SWIG_LUA_CONSTTAB_STRING("$symname", "$value")}
-
-%typemap(consttab) SWIGTYPE *, SWIGTYPE *const, SWIGTYPE &, SWIGTYPE []
-       { SWIG_LUA_POINTER, (char *)"$symname", 0, 0, (void *)$value, &$1_descriptor}
-
-// member function pointers
-%typemap(consttab) SWIGTYPE (CLASS::*)
-       { SWIG_LUA_BINARY,  (char *)"$symname", sizeof($type), 0, (void *)&$value, &$1_descriptor}
-
-
-/* -----------------------------------------------------------------------------
- *                          Overloaded operator support
- * ----------------------------------------------------------------------------- */
-// lua calls the + operator '__add'
-// python likes to call it '__add__'
-// Assuming most SWIGers will probably use the __add__ if they extend their classes
-// we have two sets of renames
-// one to rename the operator+() to __add()
-//	(this lets SWIG rename the operator overloads)
-// another is to rename __add__() to __add()
-//	(this means that people who wrote SWIG code to do that add will also work)
-
-#ifdef __cplusplus
-// this is extra renaming for lua
-// not all operators are supported, so only those that are, are listed
-%rename(__add)			*::operator+;
-%rename(__sub)			*::operator-;
-%rename(__mul)			*::operator*;
-%rename(__div)			*::operator/;
-%rename(__unm)      *::operator-();
-%rename(__unm)      *::operator-() const;
-
-%rename(__eq)			*::operator==;	
-%ignore *::operator!=;      // note: Lua does not have a notequal operator
-						// it just uses 'not (a==b)'
-%rename(__lt)			*::operator<;
-%ignore *::operator>;   	// ditto less than vs greater than
-%rename(__le)			*::operator<=;	
-%ignore *::operator>=;  // ditto less than vs greater than
-%ignore *::operator!;  // does not support not
-
-%rename(__call)			*::operator();	// the fn call operator
-
-// lua does not support overloading of:
-// 	logical/bitwise operators
-// 	assign operator
-// 	+=,-=,*=, etc
-// therefore ignoring them for now
-// it also doesn't support non class operators
-// eg friends or XX operator+(XX,XX)
-// also ignoring
-// note: some of these might be better to rename, but not doing that for now
-%ignore *::operator&&;	%ignore operator&&;
-%ignore *::operator||;	%ignore operator||;
-%ignore *::operator+=;
-%ignore *::operator-=;
-%ignore *::operator*=;
-%ignore *::operator/=;
-%ignore *::operator%=;
-%ignore *::operator++;	%ignore *::operator--;
-
-%ignore *::operator=;	// note: this might be better to rename to assign() or similar
-
-%ignore operator+;
-%ignore operator-;
-%ignore operator*;
-%ignore operator/;
-%ignore operator%;
-%ignore operator[];
-%ignore operator>;	%ignore operator>=;	
-%ignore operator<;	%ignore operator<=;
-%ignore operator==;	%ignore operator!=;
-
-
-// renaming the python operators to be compatible with lua
-// this means that if a developer has written a fn __add__()
-// it will be used for the lua +
-%rename(__add)			*::__add__;
-%rename(__sub)			*::__sub__;
-%rename(__mul)			*::__mul__;
-%rename(__div)			*::__div__;
-%rename(__unm)			*::__neg__;		// lua calls unary minus,'unm' not 'neg'
-%rename(__tostring)		*::__str__;		// both map to __tostring
-%rename(__tostring)		*::__repr__;	// both map to __tostring
-
-
-%rename(__pow)			*::__pow__;		// lua power '^' operator
-%rename(__concat)		*::__concat__;  // lua concat '..' operator
-%rename(__eq)			*::__eq__;
-%rename(__lt)			*::__lt__;
-%rename(__le)			*::__le__;
-%rename(__call)			*::__call__;	// the fn call operator()
-
-// the [] operator has two parts, the get & the set
-%rename(__getitem)			*::__getitem__;	// the v=X[i] (get operator)
-%rename(__setitem)			*::__setitem__;	// the X[i]=v (set operator)
-
-
-#endif
-
-
-/* ------------------------------------------------------------
- *                              Exceptions
- * ------------------------------------------------------------ */
-/* Confession: I don't really like C++ exceptions
-The python/lua ones are great, but C++ ones I don't like
-(mainly because I cannot get the stack trace out of it)
-Therefore I have not bothered to try doing much in this
-
-Therefore currently its just enough to get a few test cases running ok
-
-note: if you wish to throw anything related to std::exception
-use %include <std_except.i> instead
-*/
-
-// number as number+error
-%typemap(throws) int,unsigned int,signed int,
-				long,unsigned long,signed long,
-				short,unsigned short,signed short,
-				float,double,
-				long long,unsigned long long,
-				unsigned char, signed char,
-                int&,unsigned int&,signed int&,
-				long&,unsigned long&,signed long&,
-				short&,unsigned short&,signed short&,
-				float&,double&,
-				long long&,unsigned long long&,
-				unsigned char&, signed char&
-%{lua_pushnumber(L,(lua_Number)$1);SWIG_fail; %}
-
-%typemap(throws) bool,bool& 
-%{lua_pushboolean(L,(int)($1==true));SWIG_fail; %}
-
-// enum as number+error
-%typemap(throws) enum SWIGTYPE
-%{lua_pushnumber(L,(lua_Number)(int)$1);SWIG_fail; %}
-
-// strings are just sent as errors
-%typemap(throws) char *, const char *
-%{lua_pushstring(L,$1);SWIG_fail;%}
-
-// char is changed to a string
-%typemap(throws) char
-%{lua_pushfstring(L,"%c",$1);SWIG_fail;%}
-
-/*
-Throwing object is a serious problem:
-Assuming some code throws a 'FooBar'
-There are a few options:
-- return a pointer to it: but its unclear how long this will last for.
-- return a copy of it: but not all objects are copyable
-	(see exception_partial_info in the test suite for a case where you cannot do this)
-- convert to a string & throw that
-	it's not so useful, but it works (this is more lua like).
-The third option (though not nice) is used
-For a more useful solution: see std_except for more details
-*/
-
-// basic typemap for structs, classes, pointers & references
-// convert to string and error
-%typemap(throws) SWIGTYPE
-%{(void)$1; /* ignore it */
-lua_pushfstring(L,"object exception:%s",SWIG_TypePrettyName($1_descriptor));
-SWIG_fail;%}
-
-// code to make a copy of the object and return this
-// if you have a function which throws a FooBar & you want SWIG to return a copy of the object as its error
-// then use one of the below
-//	%apply SWIGTYPE EXCEPTION_BY_VAL {FooBar};
-//	%apply SWIGTYPE& EXCEPTION_BY_VAL {FooBar&}; // note: need & twice
-%typemap(throws) SWIGTYPE EXCEPTION_BY_VAL
-%{SWIG_NewPointerObj(L,(void *)new $1_ltype(($1_ltype &) $1),$&1_descriptor,1);
-SWIG_fail;%}
-
-// similar for object reference
-// note: swig typemaps seem a little confused around here, therefore we use $basetype
-%typemap(throws) SWIGTYPE& EXCEPTION_BY_VAL
-%{SWIG_NewPointerObj(L,(void *)new $basetype($1),$1_descriptor,1);
-SWIG_fail;%}
-
-
-// note: no support for object pointers
-// its not clear how long the pointer is valid for, therefore not supporting it
-
-/* -----------------------------------------------------------------------------
- *                          extras
- * ----------------------------------------------------------------------------- */
-// this %define is to allow insertion of lua source code into the wrapper file
-#define %luacode  %insert("luacode")
-
-
-/* ------------------------------ end lua.swg  ------------------------------ */
diff --git a/share/swig/2.0.11/lua/lua_fnptr.i b/share/swig/2.0.11/lua/lua_fnptr.i
deleted file mode 100644
index 4e2c8dc..0000000
--- a/share/swig/2.0.11/lua/lua_fnptr.i
+++ /dev/null
@@ -1,125 +0,0 @@
-/* -----------------------------------------------------------------------------
- * lua_fnptr.i
- *
- * SWIG Library file containing the main typemap code to support Lua modules.
- * ----------------------------------------------------------------------------- */
-
-/* -----------------------------------------------------------------------------
- *                          Basic function pointer support
- * ----------------------------------------------------------------------------- */
-/*
-The structure: SWIGLUA_FN provides a simple (local only) wrapping for a function.
-
-For example if you wanted to have a C/C++ function take a lua function as a parameter.
-You could declare it as:
-  int my_func(int a, int b, SWIGLUA_FN fn);
-note: it should be passed by value, not byref or as a pointer.
-
-The SWIGLUA_FN holds a pointer to the lua_State, and the stack index where the function is held.
-The macro SWIGLUA_FN_GET() will put a copy of the lua function at the top of the stack.
-After that its fairly simple to write the rest of the code (assuming know how to use lua),
-just push the parameters, call the function and return the result.
-
-  int my_func(int a, int b, SWIGLUA_FN fn)
-  {
-    SWIGLUA_FN_GET(fn);
-    lua_pushnumber(fn.L,a);
-    lua_pushnumber(fn.L,b);
-    lua_call(fn.L,2,1);    // 2 in, 1 out
-    return luaL_checknumber(fn.L,-1);
-  }
-
-SWIG will automatically performs the wrapping of the arguments in and out.
-
-However: if you wish to store the function between calls, look to the SWIGLUA_REF below.
-
-*/
-// this is for the C code only, we don't want SWIG to wrapper it for us.
-%{
-typedef struct{
-  lua_State* L; /* the state */
-  int idx;      /* the index on the stack */
-}SWIGLUA_FN;
-
-#define SWIGLUA_FN_GET(fn) {lua_pushvalue(fn.L,fn.idx);}
-%}
-
-// the actual typemap
-%typemap(in,checkfn="lua_isfunction") SWIGLUA_FN
-%{  $1.L=L; $1.idx=$input; %}
-
-/* -----------------------------------------------------------------------------
- *                          Storing lua object support
- * ----------------------------------------------------------------------------- */
-/*
-The structure: SWIGLUA_REF provides a mechanism to store object (usually functions)
-between calls to the interpreter.
-
-For example if you wanted to have a C/C++ function take a lua function as a parameter.
-Then call it later, You could declare it as:
-  SWIGLUA_REF myref;
-  void set_func(SWIGLUA_REF ref);
-  SWIGLUA_REF get_func();
-  void call_func(int val);
-note: it should be passed by value, not byref or as a pointer.
-
-The SWIGLUA_REF holds a pointer to the lua_State, and an integer reference to the object.
-Because it holds a permanent ref to an object, the SWIGLUA_REF must be handled with a bit more care.
-It should be initialised to {0,0}. The function swiglua_ref_set() should be used to set it.
-swiglua_ref_clear() should be used to clear it when not in use, and swiglua_ref_get() to get the
-data back.
-
-Note: the typemap does not check that the object is in fact a function,
-if you need that you must add it yourself.
-
-
-  int my_func(int a, int b, SWIGLUA_FN fn)
-  {
-    SWIGLUA_FN_GET(fn);
-    lua_pushnumber(fn.L,a);
-    lua_pushnumber(fn.L,b);
-    lua_call(fn.L,2,1);    // 2 in, 1 out
-    return luaL_checknumber(fn.L,-1);
-  }
-
-SWIG will automatically performs the wrapping of the arguments in and out.
-
-However: if you wish to store the function between calls, look to the SWIGLUA_REF below.
-
-*/
-
-%{
-typedef struct{
-  lua_State* L; /* the state */
-  int ref;      /* a ref in the lua global index */
-}SWIGLUA_REF;
-
-
-void swiglua_ref_clear(SWIGLUA_REF* pref){
- 	if (pref->L!=0 && pref->ref!=LUA_NOREF && pref->ref!=LUA_REFNIL){
-		luaL_unref(pref->L,LUA_REGISTRYINDEX,pref->ref);
-	}
-	pref->L=0; pref->ref=0;
-}
-
-void swiglua_ref_set(SWIGLUA_REF* pref,lua_State* L,int idx){
-//	swiglua_ref_clear(pref); /* just in case */
-	pref->L=L;
-	lua_pushvalue(L,idx);                 /* copy obj to top */
-	pref->ref=luaL_ref(L,LUA_REGISTRYINDEX); /* remove obj from top & put into registry */
-}
-
-void swiglua_ref_get(SWIGLUA_REF* pref){
-	if (pref->L!=0)
-		lua_rawgeti(pref->L,LUA_REGISTRYINDEX,pref->ref);
-}
-
-%}
-
-%typemap(in) SWIGLUA_REF
-%{  swiglua_ref_set(&$1,L,$input); %}
-
-%typemap(out) SWIGLUA_REF
-%{  if ($1.L!=0)  {swiglua_ref_get(&$1);} else {lua_pushnil(L);}
-  SWIG_arg++; %}
-
diff --git a/share/swig/2.0.11/lua/luarun.swg b/share/swig/2.0.11/lua/luarun.swg
deleted file mode 100644
index 4d851bd..0000000
--- a/share/swig/2.0.11/lua/luarun.swg
+++ /dev/null
@@ -1,1140 +0,0 @@
-/* -----------------------------------------------------------------------------
- * luarun.swg
- *
- * This file contains the runtime support for Lua modules
- * and includes code for managing global variables and pointer
- * type checking.
- * ----------------------------------------------------------------------------- */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "lua.h"
-#include "lauxlib.h"
-#include <stdlib.h>  /* for malloc */
-#include <assert.h>  /* for a few sanity tests */
-
-/* -----------------------------------------------------------------------------
- * Lua flavors
- * ----------------------------------------------------------------------------- */
-
-#define SWIG_LUA_FLAVOR_LUA 1
-#define SWIG_LUA_FLAVOR_ELUA 2
-#define SWIG_LUA_FLAVOR_ELUAC 3
-
-#if !defined(SWIG_LUA_TARGET)
-# error SWIG_LUA_TARGET not defined
-#endif
-
-#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
-#  define SWIG_LUA_CONSTTAB_INT(B, C) LSTRKEY(B), LNUMVAL(C)
-#  define SWIG_LUA_CONSTTAB_FLOAT(B, C) LSTRKEY(B), LNUMVAL(C)
-#  define SWIG_LUA_CONSTTAB_STRING(B, C) LSTRKEY(B), LSTRVAL(C)
-#  define SWIG_LUA_CONSTTAB_CHAR(B, C) LSTRKEY(B), LNUMVAL(C)
-#else /* SWIG_LUA_FLAVOR_LUA */
-#  define SWIG_LUA_CONSTTAB_INT(B, C) SWIG_LUA_INT, (char *)B, (long)C, 0, 0, 0
-#  define SWIG_LUA_CONSTTAB_FLOAT(B, C) SWIG_LUA_FLOAT, (char *)B, 0, (double)C, 0, 0
-#  define SWIG_LUA_CONSTTAB_STRING(B, C) SWIG_LUA_STRING, (char *)B, 0, 0, (void *)C, 0
-#  define SWIG_LUA_CONSTTAB_CHAR(B, C) SWIG_LUA_CHAR, (char *)B, (long)C, 0, 0, 0
-#endif
-
-#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
-#  define LRO_STRVAL(v) {{.p = (char *) v}, LUA_TSTRING}
-#  define LSTRVAL LRO_STRVAL
-#endif
-
-/* -----------------------------------------------------------------------------
- * compatibility defines
- * ----------------------------------------------------------------------------- */
-
-/* History of Lua C API length functions:  In Lua 5.0 (and before?)
-   there was "lua_strlen".  In Lua 5.1, this was renamed "lua_objlen",
-   but a compatibility define of "lua_strlen" was added.  In Lua 5.2,
-   this function was again renamed, to "lua_rawlen" (to emphasize that
-   it doesn't call the "__len" metamethod), and the compatibility
-   define of lua_strlen was removed.  All SWIG uses have been updated
-   to "lua_rawlen", and we add our own defines of that here for older
-   versions of Lua.  */
-#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 501
-# define lua_rawlen lua_strlen
-#elif LUA_VERSION_NUM == 501
-# define lua_rawlen lua_objlen
-#endif
-
-
-/* lua_pushglobaltable is the recommended "future-proof" way to get
-   the global table for Lua 5.2 and later.  Here we define
-   lua_pushglobaltable ourselves for Lua versions before 5.2.  */
-#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
-# define lua_pushglobaltable(L) lua_pushvalue(L, LUA_GLOBALSINDEX)
-#endif
-
-
-/* --------------------------------------------------------------------------
- * Helper functions for error handling
- * -------------------------------------------------------------------------- */
-
-/* Push the string STR on the Lua stack, like lua_pushstring, but
-   prefixed with the the location of the innermost Lua call-point
-   (as formated by luaL_where).  */
-SWIGRUNTIME void
-SWIG_Lua_pusherrstring (lua_State *L, const char *str)
-{
-  luaL_where (L, 1);
-  lua_pushstring (L, str);
-  lua_concat (L, 2);
-}
-
-/* Push a formatted string generated from FMT and following args on
-   the Lua stack, like lua_pushfstring, but prefixed with the the
-   location of the innermost Lua call-point (as formated by luaL_where).  */
-SWIGRUNTIME void
-SWIG_Lua_pushferrstring (lua_State *L, const char *fmt, ...)
-{
-  va_list argp;
-  va_start(argp, fmt);
-  luaL_where(L, 1);
-  lua_pushvfstring(L, fmt, argp);
-  va_end(argp);
-  lua_concat(L, 2);
-}
-
-
-/* -----------------------------------------------------------------------------
- * global swig types
- * ----------------------------------------------------------------------------- */
-/* Constant table */
-#define SWIG_LUA_INT     1
-#define SWIG_LUA_FLOAT   2
-#define SWIG_LUA_STRING  3
-#define SWIG_LUA_POINTER 4
-#define SWIG_LUA_BINARY  5
-#define SWIG_LUA_CHAR    6
-
-/* Structure for variable linking table */
-typedef struct {
-  const char *name;
-  lua_CFunction get;
-  lua_CFunction set;
-} swig_lua_var_info;
-
-/* Constant information structure */
-typedef struct {
-    int type;
-    char *name;
-    long lvalue;
-    double dvalue;
-    void   *pvalue;
-    swig_type_info **ptype;
-} swig_lua_const_info;
-
-typedef struct {
-  const char     *name;
-  lua_CFunction   method;
-} swig_lua_method;
-
-typedef struct {
-  const char     *name;
-  lua_CFunction   getmethod;
-  lua_CFunction   setmethod;
-} swig_lua_attribute;
-
-// Can be used to create namespaces. Currently used to
-// wrap class static methods/variables/constants
-typedef struct {
-  const char            *name;
-  swig_lua_method       *ns_methods;
-  swig_lua_attribute    *ns_attributes;
-  swig_lua_const_info   *ns_constants;
-} swig_lua_namespace;
-
-typedef struct swig_lua_class {
-  const char    *name;
-  swig_type_info   **type;
-  lua_CFunction  constructor;
-  void    (*destructor)(void *);
-  swig_lua_method   *methods;
-  swig_lua_attribute     *attributes;
-  swig_lua_namespace    cls_static;
-  struct swig_lua_class **bases;
-  const char **base_names;
-} swig_lua_class;
-
-/* this is the struct for wrapping all pointers in SwigLua
-*/
-typedef struct {
-  swig_type_info   *type;
-  int     own;  /* 1 if owned & must be destroyed */
-  void        *ptr;
-} swig_lua_userdata;
-
-/* this is the struct for wrapping arbitrary packed binary data
-(currently it is only used for member function pointers)
-the data ordering is similar to swig_lua_userdata, but it is currently not possible
-to tell the two structures apart within SWIG, other than by looking at the type
-*/
-typedef struct {
-  swig_type_info   *type;
-  int     own;  /* 1 if owned & must be destroyed */
-  char data[1];       /* arbitary amount of data */    
-} swig_lua_rawdata;
-
-/* Common SWIG API */
-#define SWIG_NewPointerObj(L, ptr, type, owner)       SWIG_Lua_NewPointerObj(L, (void *)ptr, type, owner)
-#define SWIG_ConvertPtr(L,idx, ptr, type, flags)    SWIG_Lua_ConvertPtr(L,idx,ptr,type,flags)
-#define SWIG_MustGetPtr(L,idx, type,flags, argnum,fnname)  SWIG_Lua_MustGetPtr(L,idx, type,flags, argnum,fnname)
-/* for C++ member pointers, ie, member methods */
-#define SWIG_ConvertMember(L, idx, ptr, sz, ty)       SWIG_Lua_ConvertPacked(L, idx, ptr, sz, ty)
-#define SWIG_NewMemberObj(L, ptr, sz, type)      SWIG_Lua_NewPackedObj(L, ptr, sz, type)
-
-/* Runtime API */
-#define SWIG_GetModule(clientdata) SWIG_Lua_GetModule((lua_State*)(clientdata))
-#define SWIG_SetModule(clientdata, pointer) SWIG_Lua_SetModule((lua_State*) (clientdata), pointer)
-#define SWIG_MODULE_CLIENTDATA_TYPE lua_State*
-
-/* Contract support */
-#define SWIG_contract_assert(expr, msg)  \
-  if (!(expr)) { SWIG_Lua_pusherrstring(L, (char *) msg); goto fail; } else
-
-
-/* helper #defines */
-#define SWIG_fail {goto fail;}
-#define SWIG_fail_arg(func_name,argnum,type) \
-  {SWIG_Lua_pushferrstring(L,"Error in %s (arg %d), expected '%s' got '%s'",\
-  func_name,argnum,type,SWIG_Lua_typename(L,argnum));\
-  goto fail;}
-#define SWIG_fail_ptr(func_name,argnum,type) \
-  SWIG_fail_arg(func_name,argnum,(type && type->str)?type->str:"void*")
-#define SWIG_check_num_args(func_name,a,b) \
-  if (lua_gettop(L)<a || lua_gettop(L)>b) \
-  {SWIG_Lua_pushferrstring(L,"Error in %s expected %d..%d args, got %d",func_name,a,b,lua_gettop(L));\
-  goto fail;}
-
-
-#define SWIG_Lua_get_table(L,n) \
-  (lua_pushstring(L, n), lua_rawget(L,-2))
-
-#define SWIG_Lua_add_function(L,n,f) \
-  (lua_pushstring(L, n), \
-      lua_pushcfunction(L, f), \
-      lua_rawset(L,-3))
-
-/* special helper for allowing 'nil' for usertypes */
-#define SWIG_isptrtype(L,I) (lua_isuserdata(L,I) || lua_isnil(L,I))
-
-#ifdef __cplusplus
-/* Special helper for member function pointers 
-it gets the address, casts it, then dereferences it */
-//#define SWIG_mem_fn_as_voidptr(a)  (*((char**)&(a)))
-#endif
-
-/* storing/access of swig_module_info */
-SWIGRUNTIME swig_module_info *
-SWIG_Lua_GetModule(lua_State* L) {
-  swig_module_info *ret = 0;
-  lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
-  lua_rawget(L,LUA_REGISTRYINDEX);
-  if (lua_islightuserdata(L,-1))
-    ret=(swig_module_info*)lua_touserdata(L,-1);
-  lua_pop(L,1);  /* tidy */
-  return ret;
-}
-
-SWIGRUNTIME void
-SWIG_Lua_SetModule(lua_State* L, swig_module_info *module) {
-  /* add this all into the Lua registry: */
-  lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
-  lua_pushlightuserdata(L,(void*)module);
-  lua_rawset(L,LUA_REGISTRYINDEX);
-}
-
-/* -----------------------------------------------------------------------------
- * global variable support code: modules
- * ----------------------------------------------------------------------------- */
-
-/* this function is called when trying to set an immutable.
-default action is to print an error.
-This can removed with a compile flag SWIGLUA_IGNORE_SET_IMMUTABLE */
-SWIGINTERN int SWIG_Lua_set_immutable(lua_State* L)
-{
-/*  there should be 1 param passed in: the new value */
-#ifndef SWIGLUA_IGNORE_SET_IMMUTABLE
-  lua_pop(L,1);  /* remove it */
-  luaL_error(L,"This variable is immutable");
-#endif
-    return 0;   /* should not return anything */
-}
-
-/* the module.get method used for getting linked data */
-SWIGINTERN int SWIG_Lua_module_get(lua_State* L)
-{
-/*  there should be 2 params passed in
-  (1) table (not the meta table)
-  (2) string name of the attribute
-  printf("SWIG_Lua_module_get %p(%s) '%s'\n",
-   lua_topointer(L,1),lua_typename(L,lua_type(L,1)),
-   lua_tostring(L,2));
-*/
-  /* get the metatable */
-#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
-  assert(lua_isrotable(L,1)); /* just in case */
-#else
-  assert(lua_istable(L,1)); /* default Lua action */
-#endif
-  lua_getmetatable(L,1);  /* get the metatable */
-#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
-  assert(lua_isrotable(L,-1));  /* just in case */
-#else
-  assert(lua_istable(L,-1));
-#endif
-  SWIG_Lua_get_table(L,".get");  /* get the .get table */
-  lua_remove(L,3);  /* remove metatable */
-#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
-  if (lua_isrotable(L,-1))
-#else
-  if (lua_istable(L,-1))
-#endif
-  {
-    /* look for the key in the .get table */
-    lua_pushvalue(L,2);  /* key */
-    lua_rawget(L,-2);
-    lua_remove(L,3);  /* remove .get */
-    if (lua_iscfunction(L,-1))
-    {  /* found it so call the fn & return its value */
-      lua_call(L,0,1);
-      return 1;
-    }
-    lua_pop(L,1);  /* remove the top */
-  }
-  lua_pop(L,1);  /* remove the .get */
-  lua_pushnil(L);  /* return a nil */
-  return 1;
-}
-
-/* the module.set method used for setting linked data */
-SWIGINTERN int SWIG_Lua_module_set(lua_State* L)
-{
-/*  there should be 3 params passed in
-  (1) table (not the meta table)
-  (2) string name of the attribute
-  (3) any for the new value
-*/
-  /* get the metatable */
-#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
-  assert(lua_isrotable(L,1));  /* just in case */
-#else
-  assert(lua_istable(L,1)); /* default Lua action */
-#endif
-  lua_getmetatable(L,1);  /* get the metatable */
-#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
-  assert(lua_isrotable(L,-1));  /* just in case */
-#else
-  assert(lua_istable(L,-1));
-#endif
-  SWIG_Lua_get_table(L,".set");  /* get the .set table */
-  lua_remove(L,4);  /* remove metatable */
-#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
-  if (lua_isrotable(L,-1))
-#else
-  if (lua_istable(L,-1))
-#endif
-  {
-    /* look for the key in the .set table */
-    lua_pushvalue(L,2);  /* key */
-    lua_rawget(L,-2);
-    lua_remove(L,4);  /* remove .set */
-    if (lua_iscfunction(L,-1))
-    {  /* found it so call the fn & return its value */
-      lua_pushvalue(L,3);  /* value */
-      lua_call(L,1,0);
-      return 0;
-    }
-#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) 
-    else {
-      return 0; // Exits stoically if an invalid key is initialized.
-    }
-#endif
-  }
-  lua_settop(L,3);  /* reset back to start */
-  /* we now have the table, key & new value, so just set directly */
-  lua_rawset(L,1);  /* add direct */
-  return 0;
-}
-
-#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC))
-/* registering a module in lua. Pushes the module table on the stack. */
-SWIGINTERN void  SWIG_Lua_module_begin(lua_State* L,const char* name)
-{
-  assert(lua_istable(L,-1));  /* just in case */
-  lua_pushstring(L,name);
-  lua_newtable(L);   /* the table */
-  /* add meta table */
-  lua_newtable(L);    /* the meta table */
-  SWIG_Lua_add_function(L,"__index",SWIG_Lua_module_get);
-  SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_module_set);
-  lua_pushstring(L,".get");
-  lua_newtable(L);    /* the .get table */
-  lua_rawset(L,-3);  /* add .get into metatable */
-  lua_pushstring(L,".set");
-  lua_newtable(L);    /* the .set table */
-  lua_rawset(L,-3);  /* add .set into metatable */
-  lua_setmetatable(L,-2);  /* sets meta table in module */
-#ifdef SWIG_LUA_MODULE_GLOBAL
-  /* If requested, install the module directly into the global namespace. */
-  lua_rawset(L,-3);        /* add module into parent */
-  SWIG_Lua_get_table(L,name);   /* get the table back out */
-#else
-  /* Do not install the module table as global name. The stack top has
-     the module table with the name below. We pop the top and replace
-     the name with it. */
-  lua_replace(L,-2);
-#endif
-}
-
-/* ending the register */
-SWIGINTERN void  SWIG_Lua_module_end(lua_State* L)
-{
-  lua_pop(L,1);       /* tidy stack (remove module) */
-}
-
-/* adding a linked variable to the module */
-SWIGINTERN void SWIG_Lua_module_add_variable(lua_State* L,const char* name,lua_CFunction getFn,lua_CFunction setFn)
-{
-  assert(lua_istable(L,-1));  /* just in case */
-  lua_getmetatable(L,-1);  /* get the metatable */
-  assert(lua_istable(L,-1));  /* just in case */
-  SWIG_Lua_get_table(L,".get"); /* find the .get table */
-  assert(lua_istable(L,-1));  /* should be a table: */
-  SWIG_Lua_add_function(L,name,getFn);
-  lua_pop(L,1);       /* tidy stack (remove table) */
-  if (setFn)  /* if there is a set fn */
-  {
-    SWIG_Lua_get_table(L,".set"); /* find the .set table */
-    assert(lua_istable(L,-1));  /* should be a table: */
-    SWIG_Lua_add_function(L,name,setFn);
-    lua_pop(L,1);       /* tidy stack (remove table) */
-  }
-  lua_pop(L,1);       /* tidy stack (remove meta) */
-}
-#endif
-
-/* adding a function module */
-SWIGINTERN void  SWIG_Lua_module_add_function(lua_State* L,const char* name,lua_CFunction fn)
-{
-  SWIG_Lua_add_function(L,name,fn);
-}
-
-/* -----------------------------------------------------------------------------
- * global variable support code: namespaces
- * ----------------------------------------------------------------------------- */
-
-SWIGINTERN int SWIG_Lua_namespace_get(lua_State* L)
-{
-/*  there should be 2 params passed in
-  (1) table (not the meta table)
-  (2) string name of the attribute
-*/
-  assert(lua_istable(L,-2));  /* just in case */
-  lua_getmetatable(L,-2);
-  assert(lua_istable(L,-1));
-  SWIG_Lua_get_table(L,".get"); /* find the .get table */
-  assert(lua_istable(L,-1));
-  /* look for the key in the .get table */
-  lua_pushvalue(L,2);  /* key */
-  lua_rawget(L,-2);
-  lua_remove(L,-2); /* stack tidy, remove .get table */
-  if (lua_iscfunction(L,-1))
-  {  /* found it so call the fn & return its value */
-    lua_call(L,0,1);  /* 1 value in (userdata),1 out (result) */
-    lua_remove(L,-2); /* stack tidy, remove metatable */
-    return 1;
-  }
-  lua_pop(L,1);  /* remove whatever was there */
-  /* ok, so try the .fn table */
-  SWIG_Lua_get_table(L,".fn"); /* find the .get table */
-  assert(lua_istable(L,-1));  /* just in case */
-  lua_pushvalue(L,2);  /* key */
-  lua_rawget(L,-2);  /* look for the fn */
-  lua_remove(L,-2); /* stack tidy, remove .fn table */
-  if (lua_isfunction(L,-1)) /* note: whether it's a C function or lua function */
-  {  /* found it so return the fn & let lua call it */
-    lua_remove(L,-2); /* stack tidy, remove metatable */
-    return 1;
-  }
-  lua_pop(L,1);  /* remove whatever was there */
-  return 0;
-}
-
-SWIGINTERN int SWIG_Lua_namespace_set(lua_State* L)
-{
-/*  there should be 3 params passed in
-  (1) table (not the meta table)
-  (2) string name of the attribute
-  (3) any for the new value
-*/
-
-  assert(lua_istable(L,1));
-  lua_getmetatable(L,1);    /* get the meta table */
-  assert(lua_istable(L,-1));
-
-  SWIG_Lua_get_table(L,".set"); /* find the .set table */
-  if (lua_istable(L,-1))
-  {
-    /* look for the key in the .set table */
-    lua_pushvalue(L,2);  /* key */
-    lua_rawget(L,-2);
-    if (lua_iscfunction(L,-1))
-    {  /* found it so call the fn & return its value */
-      lua_pushvalue(L,3);  /* value */
-      lua_call(L,1,0);
-      return 0;
-    }
-    lua_pop(L,1);  /* remove the value */
-  }
-  lua_pop(L,1);  /* remove the value .set table */
-  return 0;
-}
-
-SWIGINTERN void SWIG_Lua_InstallConstants(lua_State* L, swig_lua_const_info constants[]); // forward declaration
-SWIGINTERN void  SWIG_Lua_add_class_variable(lua_State* L,const char* name,lua_CFunction getFn,lua_CFunction setFn); // forward declaration
-
-/* helper function - register namespace methods and attributes into namespace */
-SWIGINTERN int SWIG_Lua_add_namespace_details(lua_State* L, swig_lua_namespace* ns)
-{
-  int i = 0;
-  assert(lua_istable(L,-1));
-  /* There must be table at the top of the stack */
-  SWIG_Lua_InstallConstants(L, ns->ns_constants);
-
-  lua_getmetatable(L,-1);
-
-  /* add fns */
-  for(i=0;ns->ns_attributes[i].name;i++){
-    SWIG_Lua_add_class_variable(L,ns->ns_attributes[i].name,ns->ns_attributes[i].getmethod,ns->ns_attributes[i].setmethod);
-  }
-
-  /* add methods to the metatable */
-  SWIG_Lua_get_table(L,".fn"); /* find the .fn table */
-  assert(lua_istable(L,-1));  /* just in case */
-  for(i=0;ns->ns_methods[i].name;i++){
-    SWIG_Lua_add_function(L,ns->ns_methods[i].name,ns->ns_methods[i].method);
-  }
-  lua_pop(L,1);
-
-  /* clear stack - remove metatble */
-  lua_pop(L,1);
-
-}
-
-/* helper function. creates namespace table and add it to module table */
-SWIGINTERN int SWIG_Lua_namespace_register(lua_State* L, swig_lua_namespace* ns)
-{
-  assert(lua_istable(L,-1)); /* just in case. This is supposed to be module table */
-  lua_checkstack(L,5);
-  lua_pushstring(L, ns->name);
-  lua_newtable(L); /* namespace itself */
-  lua_newtable(L); /* metatable for namespace */
-
-  /* add a table called ".get" */
-  lua_pushstring(L,".get");
-  lua_newtable(L);
-  lua_rawset(L,-3);
-  /* add a table called ".set" */
-  lua_pushstring(L,".set");
-  lua_newtable(L);
-  lua_rawset(L,-3);
-  /* add a table called ".fn" */
-  lua_pushstring(L,".fn");
-  lua_newtable(L);
-  lua_rawset(L,-3);
-
-  /* add accessor fns for using the .get,.set&.fn */
-  SWIG_Lua_add_function(L,"__index",SWIG_Lua_namespace_get);
-  SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_namespace_set);
-
-  lua_setmetatable(L,-2); /* set metatable */
-  lua_rawset(L,-3); /* add namespace to module table */
-}
-/* -----------------------------------------------------------------------------
- * global variable support code: classes
- * ----------------------------------------------------------------------------- */
-
-/* the class.get method, performs the lookup of class attributes */
-SWIGINTERN int  SWIG_Lua_class_get(lua_State* L)
-{
-/*  there should be 2 params passed in
-  (1) userdata (not the meta table)
-  (2) string name of the attribute
-*/
-  assert(lua_isuserdata(L,-2));  /* just in case */
-  lua_getmetatable(L,-2);    /* get the meta table */
-  assert(lua_istable(L,-1));  /* just in case */
-  SWIG_Lua_get_table(L,".get"); /* find the .get table */
-  assert(lua_istable(L,-1));  /* just in case */
-  /* look for the key in the .get table */
-  lua_pushvalue(L,2);  /* key */
-  lua_rawget(L,-2);
-  lua_remove(L,-2); /* stack tidy, remove .get table */
-  if (lua_iscfunction(L,-1))
-  {  /* found it so call the fn & return its value */
-    lua_pushvalue(L,1);  /* the userdata */
-    lua_call(L,1,1);  /* 1 value in (userdata),1 out (result) */
-    lua_remove(L,-2); /* stack tidy, remove metatable */
-    return 1;
-  }
-  lua_pop(L,1);  /* remove whatever was there */
-  /* ok, so try the .fn table */
-  SWIG_Lua_get_table(L,".fn"); /* find the .get table */
-  assert(lua_istable(L,-1));  /* just in case */
-  lua_pushvalue(L,2);  /* key */
-  lua_rawget(L,-2);  /* look for the fn */
-  lua_remove(L,-2); /* stack tidy, remove .fn table */
-  if (lua_isfunction(L,-1)) /* note: if its a C function or lua function */
-  {  /* found it so return the fn & let lua call it */
-    lua_remove(L,-2); /* stack tidy, remove metatable */
-    return 1;
-  }
-  lua_pop(L,1);  /* remove whatever was there */
-  /* NEW: looks for the __getitem() fn
-  this is a user provided get fn */
-  SWIG_Lua_get_table(L,"__getitem"); /* find the __getitem fn */
-  if (lua_iscfunction(L,-1))  /* if its there */
-  {  /* found it so call the fn & return its value */
-    lua_pushvalue(L,1);  /* the userdata */
-    lua_pushvalue(L,2);  /* the parameter */
-    lua_call(L,2,1);  /* 2 value in (userdata),1 out (result) */
-    lua_remove(L,-2); /* stack tidy, remove metatable */
-    return 1;
-  }
-  return 0;  /* sorry not known */
-}
-
-/* the class.set method, performs the lookup of class attributes */
-SWIGINTERN int  SWIG_Lua_class_set(lua_State* L)
-{
-/*  there should be 3 params passed in
-  (1) table (not the meta table)
-  (2) string name of the attribute
-  (3) any for the new value
-printf("SWIG_Lua_class_set %p(%s) '%s' %p(%s)\n",
-      lua_topointer(L,1),lua_typename(L,lua_type(L,1)),
-      lua_tostring(L,2),
-      lua_topointer(L,3),lua_typename(L,lua_type(L,3)));*/
-
-  assert(lua_isuserdata(L,1));  /* just in case */
-  lua_getmetatable(L,1);    /* get the meta table */
-  assert(lua_istable(L,-1));  /* just in case */
-
-  SWIG_Lua_get_table(L,".set"); /* find the .set table */
-  if (lua_istable(L,-1))
-  {
-    /* look for the key in the .set table */
-    lua_pushvalue(L,2);  /* key */
-    lua_rawget(L,-2);
-    if (lua_iscfunction(L,-1))
-    {  /* found it so call the fn & return its value */
-      lua_pushvalue(L,1);  /* userdata */
-      lua_pushvalue(L,3);  /* value */
-      lua_call(L,2,0);
-      return 0;
-    }
-    lua_pop(L,1);  /* remove the value */
-  }
-  lua_pop(L,1);  /* remove the value .set table */
-  /* NEW: looks for the __setitem() fn
-  this is a user provided set fn */
-  SWIG_Lua_get_table(L,"__setitem"); /* find the fn */
-  if (lua_iscfunction(L,-1))  /* if its there */
-  {  /* found it so call the fn & return its value */
-    lua_pushvalue(L,1);  /* the userdata */
-    lua_pushvalue(L,2);  /* the parameter */
-    lua_pushvalue(L,3);  /* the value */
-    lua_call(L,3,0);  /* 3 values in ,0 out */
-    lua_remove(L,-2); /* stack tidy, remove metatable */
-    return 1;
-  }
-  return 0;
-}
-
-/* the class.destruct method called by the interpreter */
-SWIGINTERN int  SWIG_Lua_class_destruct(lua_State* L)
-{
-/*  there should be 1 params passed in
-  (1) userdata (not the meta table) */
-  swig_lua_userdata* usr;
-  swig_lua_class* clss;
-  assert(lua_isuserdata(L,-1));  /* just in case */
-  usr=(swig_lua_userdata*)lua_touserdata(L,-1);  /* get it */
-  /* if must be destroyed & has a destructor */
-  if (usr->own) /* if must be destroyed */
-  {
-    clss=(swig_lua_class*)usr->type->clientdata;  /* get the class */
-    if (clss && clss->destructor)  /* there is a destroy fn */
-    {
-      clss->destructor(usr->ptr);  /* bye bye */
-    }
-  }
-  return 0;
-}
-
-/* the class.__tostring method called by the interpreter and print */
-SWIGINTERN int  SWIG_Lua_class_tostring(lua_State* L)
-{
-/*  there should be 1 param passed in
-  (1) userdata (not the metatable) */
-  assert(lua_isuserdata(L,1));  /* just in case */
-  unsigned long userData = (unsigned long)lua_touserdata(L,1); /* get the userdata address for later */
-  lua_getmetatable(L,1);    /* get the meta table */
-  assert(lua_istable(L,-1));  /* just in case */
-  
-  lua_getfield(L, -1, ".type");
-  const char* className = lua_tostring(L, -1);
-  
-  char output[256];
-  sprintf(output, "<%s userdata: %lX>", className, userData);
-  
-  lua_pushstring(L, (const char*)output);
-  return 1;
-}
-
-/* to manually disown some userdata */
-SWIGINTERN int  SWIG_Lua_class_disown(lua_State* L)
-{
-/*  there should be 1 params passed in
-  (1) userdata (not the meta table) */
-  swig_lua_userdata* usr;
-  assert(lua_isuserdata(L,-1));  /* just in case */
-  usr=(swig_lua_userdata*)lua_touserdata(L,-1);  /* get it */
-  
-  usr->own = 0; /* clear our ownership */
-  return 0;
-}
-
-/* Constructor proxy. Used when class name entry in module is not class constructor,
-but special table instead. */
-SWIGINTERN int SWIG_Lua_constructor_proxy(lua_State* L)
-{
-  /* unlimited number of parameters
-     First one is our proxy table and we should remove it
-     Other we should pass to real constructor
-   */
-   assert(lua_istable(L,1));
-   lua_pushstring(L,".constructor");
-   lua_rawget(L,1);
-   assert(!lua_isnil(L,-1));
-   lua_replace(L,1); /* replace our table with real constructor */
-   lua_call(L,lua_gettop(L)-1,1);
-   return 1;
-}
-
-/* gets the swig class registry (or creates it) */
-SWIGINTERN void  SWIG_Lua_get_class_registry(lua_State* L)
-{
-  /* add this all into the swig registry: */
-  lua_pushstring(L,"SWIG");
-  lua_rawget(L,LUA_REGISTRYINDEX);  /* get the registry */
-  if (!lua_istable(L,-1))  /* not there */
-  {  /* must be first time, so add it */
-    lua_pop(L,1);  /* remove the result */
-    lua_pushstring(L,"SWIG");
-    lua_newtable(L);
-    lua_rawset(L,LUA_REGISTRYINDEX);
-    /* then get it */
-    lua_pushstring(L,"SWIG");
-    lua_rawget(L,LUA_REGISTRYINDEX);
-  }
-}
-
-/* helper fn to get the classes metatable from the register */
-SWIGINTERN void  SWIG_Lua_get_class_metatable(lua_State* L,const char* cname)
-{
-  SWIG_Lua_get_class_registry(L);  /* get the registry */
-  lua_pushstring(L,cname);  /* get the name */
-  lua_rawget(L,-2);    /* get it */
-  lua_remove(L,-2);    /* tidy up (remove registry) */
-}
-
-/* helper add a variable to a registered class */
-SWIGINTERN void  SWIG_Lua_add_class_variable(lua_State* L,const char* name,lua_CFunction getFn,lua_CFunction setFn)
-{
-  assert(lua_istable(L,-1));  /* just in case */
-  SWIG_Lua_get_table(L,".get"); /* find the .get table */
-  assert(lua_istable(L,-1));  /* just in case */
-  SWIG_Lua_add_function(L,name,getFn);
-  lua_pop(L,1);       /* tidy stack (remove table) */
-  if (setFn)
-  {
-    SWIG_Lua_get_table(L,".set"); /* find the .set table */
-    assert(lua_istable(L,-1));  /* just in case */
-    SWIG_Lua_add_function(L,name,setFn);
-    lua_pop(L,1);       /* tidy stack (remove table) */
-  }
-}
-
-/* helper to recursively add class static details (static attributes, operations and constants) */
-SWIGINTERN void SWIG_Lua_add_class_static_details(lua_State* L, swig_lua_class* clss)
-{
-  int i = 0;
-  /* The class namespace table must be on the top of the stack */
-  assert(lua_istable(L,-1));
-  /* call all the base classes first: we can then override these later: */
-  for(i=0;clss->bases[i];i++)
-  {
-    SWIG_Lua_add_class_static_details(L,clss->bases[i]);
-  }
-
-  SWIG_Lua_add_namespace_details(L, &clss->cls_static);
-}
-
-/* helper to recursively add class details (attributes & operations) */
-SWIGINTERN void  SWIG_Lua_add_class_details(lua_State* L,swig_lua_class* clss)
-{
-  int i;
-  /* call all the base classes first: we can then override these later: */
-  for(i=0;clss->bases[i];i++)
-  {
-    SWIG_Lua_add_class_details(L,clss->bases[i]);
-  }
-  /* add fns */
-  for(i=0;clss->attributes[i].name;i++){
-    SWIG_Lua_add_class_variable(L,clss->attributes[i].name,clss->attributes[i].getmethod,clss->attributes[i].setmethod);
-  }
-  /* add methods to the metatable */
-  SWIG_Lua_get_table(L,".fn"); /* find the .fn table */
-  assert(lua_istable(L,-1));  /* just in case */
-  for(i=0;clss->methods[i].name;i++){
-    SWIG_Lua_add_function(L,clss->methods[i].name,clss->methods[i].method);
-  }
-  lua_pop(L,1);       /* tidy stack (remove table) */
-  /*   add operator overloads
-    these look ANY method which start with "__" and assume they
-    are operator overloads & add them to the metatable
-    (this might mess up is someone defines a method __gc (the destructor)*/
-  for(i=0;clss->methods[i].name;i++){
-    if (clss->methods[i].name[0]=='_' && clss->methods[i].name[1]=='_'){
-      SWIG_Lua_add_function(L,clss->methods[i].name,clss->methods[i].method);
-    }
-  }
-}
-
-/* set up the base classes pointers.
-Each class structure has a list of pointers to the base class structures.
-This function fills them.
-It cannot be done at compile time, as this will not work with hireachies
-spread over more than one swig file. 
-Therefore it must be done at runtime, querying the SWIG type system.
-*/
-SWIGINTERN void SWIG_Lua_init_base_class(lua_State* L,swig_lua_class* clss)
-{
-  int i=0;
-  swig_module_info* module=SWIG_GetModule(L);
-  for(i=0;clss->base_names[i];i++)
-  {
-    if (clss->bases[i]==0) /* not found yet */
-    {
-      /* lookup and cache the base class */
-      swig_type_info *info = SWIG_TypeQueryModule(module,module,clss->base_names[i]);
-      if (info) clss->bases[i] = (swig_lua_class *) info->clientdata;
-    }
-  }
-}
-
-/* Register class static methods,attributes etc as well as constructor proxy */
-SWIGINTERN void SWIG_Lua_class_register_static(lua_State* L, swig_lua_class* clss)
-{
-  lua_checkstack(L,5); /* just in case */
-  assert(lua_istable(L,-1));  /* just in case */
-  assert(strcmp(clss->name, clss->cls_static.name) == 0); /* in class those 2 must be equal */
-
-  SWIG_Lua_namespace_register(L,&clss->cls_static);
-
-  SWIG_Lua_get_table(L,clss->name); // Get namespace table back
-  assert(lua_istable(L,-1)); /* just in case */
-
-  /*  add its constructor to module with the name of the class
-  so you can do MyClass(...) as well as new_MyClass(...)
-  BUT only if a constructor is defined
-  (this overcomes the problem of pure virtual classes without constructors)*/
-  if (clss->constructor)
-  {
-    SWIG_Lua_add_function(L,".constructor", clss->constructor);
-    lua_getmetatable(L,-1);
-    assert(lua_istable(L,-1)); /* just in case */
-    SWIG_Lua_add_function(L,"__call", SWIG_Lua_constructor_proxy);
-    lua_pop(L,1);
-  }
-
-  assert(lua_istable(L,-1)); /* just in case */
-  SWIG_Lua_add_class_static_details(L, clss);
-
-  /* clear stack */
-  lua_pop(L,1);
-}
-
-/* performs the entire class registration process */
-SWIGINTERN void  SWIG_Lua_class_register(lua_State* L,swig_lua_class* clss)
-{
-  SWIG_Lua_class_register_static(L,clss);
-
-  SWIG_Lua_get_class_registry(L);  /* get the registry */
-  lua_pushstring(L,clss->name);  /* get the name */
-  lua_newtable(L);    /* create the metatable */
-  /* add string of class name called ".type" */
-  lua_pushstring(L,".type");
-  lua_pushstring(L,clss->name);
-  lua_rawset(L,-3);
-  /* add a table called ".get" */
-  lua_pushstring(L,".get");
-  lua_newtable(L);
-  lua_rawset(L,-3);
-  /* add a table called ".set" */
-  lua_pushstring(L,".set");
-  lua_newtable(L);
-  lua_rawset(L,-3);
-  /* add a table called ".fn" */
-  lua_pushstring(L,".fn");
-  lua_newtable(L);
-  /* add manual disown method */
-  SWIG_Lua_add_function(L,"__disown",SWIG_Lua_class_disown);
-  lua_rawset(L,-3);
-  /* add accessor fns for using the .get,.set&.fn */
-  SWIG_Lua_add_function(L,"__index",SWIG_Lua_class_get);
-  SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_class_set);
-  SWIG_Lua_add_function(L,"__gc",SWIG_Lua_class_destruct);
-  /* add tostring method for better output */
-  SWIG_Lua_add_function(L,"__tostring",SWIG_Lua_class_tostring);
-  /* add it */
-  lua_rawset(L,-3);  /* metatable into registry */
-  lua_pop(L,1);      /* tidy stack (remove registry) */
-
-  SWIG_Lua_get_class_metatable(L,clss->name);
-  SWIG_Lua_add_class_details(L,clss);  /* recursive adding of details (atts & ops) */
-  lua_pop(L,1);      /* tidy stack (remove class metatable) */
-}
-
-/* -----------------------------------------------------------------------------
- * Class/structure conversion fns
- * ----------------------------------------------------------------------------- */
-
-/* helper to add metatable to new lua object */
-SWIGINTERN void _SWIG_Lua_AddMetatable(lua_State* L,swig_type_info *type)
-{
-  if (type->clientdata)  /* there is clientdata: so add the metatable */
-  {
-    SWIG_Lua_get_class_metatable(L,((swig_lua_class*)(type->clientdata))->name);
-    if (lua_istable(L,-1))
-    {
-      lua_setmetatable(L,-2);
-    }
-    else
-    {
-      lua_pop(L,1);
-    }
-  }
-}
-
-/* pushes a new object into the lua stack */
-SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State* L,void* ptr,swig_type_info *type, int own)
-{
-  swig_lua_userdata* usr;
-  if (!ptr){
-    lua_pushnil(L);
-    return;
-  }
-  usr=(swig_lua_userdata*)lua_newuserdata(L,sizeof(swig_lua_userdata));  /* get data */
-  usr->ptr=ptr;  /* set the ptr */
-  usr->type=type;
-  usr->own=own;
-#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
-  _SWIG_Lua_AddMetatable(L,type); /* add metatable */
-#endif
-}
-
-/* takes a object from the lua stack & converts it into an object of the correct type
- (if possible) */
-SWIGRUNTIME int  SWIG_Lua_ConvertPtr(lua_State* L,int index,void** ptr,swig_type_info *type,int flags)
-{
-  swig_lua_userdata* usr;
-  swig_cast_info *cast;
-  if (lua_isnil(L,index)){*ptr=0; return SWIG_OK;}    /* special case: lua nil => NULL pointer */
-  usr=(swig_lua_userdata*)lua_touserdata(L,index);  /* get data */
-  if (usr)
-  {
-    if (flags & SWIG_POINTER_DISOWN) /* must disown the object */
-    {
-        usr->own=0;
-    }
-    if (!type)            /* special cast void*, no casting fn */
-    {
-      *ptr=usr->ptr;
-      return SWIG_OK; /* ok */
-    }
-    cast=SWIG_TypeCheckStruct(usr->type,type); /* performs normal type checking */
-    if (cast)
-    {
-      int newmemory = 0;
-      *ptr=SWIG_TypeCast(cast,usr->ptr,&newmemory);
-      assert(!newmemory); /* newmemory handling not yet implemented */
-      return SWIG_OK;  /* ok */
-    }
-  }
-  return SWIG_ERROR;  /* error */
-}
-
-SWIGRUNTIME void* SWIG_Lua_MustGetPtr(lua_State* L,int index,swig_type_info *type,int flags,
-       int argnum,const char* func_name){
-  void* result;
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,index,&result,type,flags))){
-    luaL_error (L,"Error in %s, expected a %s at argument number %d\n",
-		func_name,(type && type->str)?type->str:"void*",argnum);
-  }
-  return result;
-}
-
-/* pushes a packed userdata. user for member fn pointers only */
-SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State* L,void* ptr,size_t size,swig_type_info *type)
-{
-  swig_lua_rawdata* raw;
-  assert(ptr); /* not acceptable to pass in a NULL value */
-  raw=(swig_lua_rawdata*)lua_newuserdata(L,sizeof(swig_lua_rawdata)-1+size);  /* alloc data */
-  raw->type=type;
-  raw->own=0;
-  memcpy(raw->data,ptr,size); /* copy the data */
-  _SWIG_Lua_AddMetatable(L,type); /* add metatable */
-}
-    
-/* converts a packed userdata. user for member fn pointers only */
-SWIGRUNTIME int  SWIG_Lua_ConvertPacked(lua_State* L,int index,void* ptr,size_t size,swig_type_info *type)
-{
-  swig_lua_rawdata* raw;
-  raw=(swig_lua_rawdata*)lua_touserdata(L,index);  /* get data */
-  if (!raw) return SWIG_ERROR;  /* error */
-  if (type==0 || type==raw->type) /* void* or identical type */
-  {
-    memcpy(ptr,raw->data,size); /* copy it */
-    return SWIG_OK; /* ok */
-  }
-  return SWIG_ERROR;  /* error */
-}
-
-/* a function to get the typestring of a piece of data */
-SWIGRUNTIME const char *SWIG_Lua_typename(lua_State *L, int tp)
-{
-  swig_lua_userdata* usr;
-  if (lua_isuserdata(L,tp))
-  {
-    usr=(swig_lua_userdata*)lua_touserdata(L,tp);  /* get data */
-    if (usr && usr->type && usr->type->str)
-      return usr->type->str;
-    return "userdata (unknown type)";
-  }
-  return lua_typename(L,lua_type(L,tp));
-}
-
-/* lua callable function to get the userdata's type */
-SWIGRUNTIME int SWIG_Lua_type(lua_State* L)
-{
-  lua_pushstring(L,SWIG_Lua_typename(L,1));
-  return 1;
-}
-
-/* lua callable function to compare userdata's value
-the issue is that two userdata may point to the same thing
-but to lua, they are different objects */
-SWIGRUNTIME int SWIG_Lua_equal(lua_State* L)
-{
-  int result;
-  swig_lua_userdata *usr1,*usr2;
-  if (!lua_isuserdata(L,1) || !lua_isuserdata(L,2))  /* just in case */
-    return 0;  /* nil reply */
-  usr1=(swig_lua_userdata*)lua_touserdata(L,1);  /* get data */
-  usr2=(swig_lua_userdata*)lua_touserdata(L,2);  /* get data */
-  /*result=(usr1->ptr==usr2->ptr && usr1->type==usr2->type); only works if type is the same*/
-  result=(usr1->ptr==usr2->ptr);
-   lua_pushboolean(L,result);
-  return 1;
-}
-
-/* -----------------------------------------------------------------------------
- * global variable support code: class/struct typemap functions
- * ----------------------------------------------------------------------------- */
-
-#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC))
-/* Install Constants */
-SWIGINTERN void
-SWIG_Lua_InstallConstants(lua_State* L, swig_lua_const_info constants[]) {
-  int i;
-  for (i = 0; constants[i].type; i++) {
-    switch(constants[i].type) {
-    case SWIG_LUA_INT:
-      lua_pushstring(L,constants[i].name);
-      lua_pushnumber(L,(lua_Number)constants[i].lvalue);
-      lua_rawset(L,-3);
-      break;
-    case SWIG_LUA_FLOAT:
-      lua_pushstring(L,constants[i].name);
-      lua_pushnumber(L,(lua_Number)constants[i].dvalue);
-      lua_rawset(L,-3);
-      break;
-    case SWIG_LUA_CHAR:
-      lua_pushstring(L,constants[i].name);
-      lua_pushfstring(L,"%c",(char)constants[i].lvalue);
-      lua_rawset(L,-3);
-      break;
-    case SWIG_LUA_STRING:
-      lua_pushstring(L,constants[i].name);
-      lua_pushstring(L,(char *) constants[i].pvalue);
-      lua_rawset(L,-3);
-      break;
-    case SWIG_LUA_POINTER:
-      lua_pushstring(L,constants[i].name);
-      SWIG_NewPointerObj(L,constants[i].pvalue, *(constants[i]).ptype,0);
-      lua_rawset(L,-3);
-      break;
-    case SWIG_LUA_BINARY:
-      lua_pushstring(L,constants[i].name);
-      SWIG_NewMemberObj(L,constants[i].pvalue,constants[i].lvalue,*(constants[i]).ptype);
-      lua_rawset(L,-3);
-      break;
-    default:
-      break;
-    }
-  }
-}
-#endif
-
-/* -----------------------------------------------------------------------------
- * executing lua code from within the wrapper
- * ----------------------------------------------------------------------------- */
-
-#ifndef SWIG_DOSTRING_FAIL /* Allows redefining of error function */
-#define SWIG_DOSTRING_FAIL(S) fprintf(stderr,"%s\n",S)
-#endif
-/* Executes a C string in Lua which is a really simple way of calling lua from C
-Unfortunately lua keeps changing its APIs, so we need a conditional compile
-In lua 5.0.X its lua_dostring()
-In lua 5.1.X its luaL_dostring()
-*/
-SWIGINTERN int 
-SWIG_Lua_dostring(lua_State *L, const char* str) {
-  int ok,top;
-  if (str==0 || str[0]==0) return 0; /* nothing to do */
-  top=lua_gettop(L); /* save stack */
-#if (defined(LUA_VERSION_NUM) && (LUA_VERSION_NUM>=501))
-  ok=luaL_dostring(L,str);	/* looks like this is lua 5.1.X or later, good */
-#else
-  ok=lua_dostring(L,str);	/* might be lua 5.0.x, using lua_dostring */
-#endif
-  if (ok!=0) {
-    SWIG_DOSTRING_FAIL(lua_tostring(L,-1));
-  }
-  lua_settop(L,top); /* restore the stack */
-  return ok;
-}    
-
-#ifdef __cplusplus
-}
-#endif
-
-/* ------------------------------ end luarun.swg  ------------------------------ */
diff --git a/share/swig/2.0.11/lua/luaruntime.swg b/share/swig/2.0.11/lua/luaruntime.swg
deleted file mode 100644
index 423c719..0000000
--- a/share/swig/2.0.11/lua/luaruntime.swg
+++ /dev/null
@@ -1,95 +0,0 @@
-/* -----------------------------------------------------------------------------
- * luaruntime.swg
- *
- * all the runtime code for .
- * ----------------------------------------------------------------------------- */
-
-%runtime "swigrun.swg";         /* Common C API type-checking code */
-%runtime "luarun.swg";          /* Lua runtime stuff */
-
-%insert(initbeforefunc) "swiginit.swg"
-
-%insert(initbeforefunc) %{
-
-/* Forward declaration of where the user's %init{} gets inserted */
-void SWIG_init_user(lua_State* L );
-    
-#ifdef __cplusplus
-extern "C" {
-#endif
-/* this is the initialization function
-  added at the very end of the code
-  the function is always called SWIG_init, but an earlier #define will rename it
-*/
-#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
-LUALIB_API int SWIG_init(lua_State* L)
-#else
-SWIGEXPORT int SWIG_init(lua_State* L) /* default Lua action */
-#endif
-{
-#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) /* valid for both Lua and eLua */
-  int i;
-  /* start with global table */
-  lua_pushglobaltable (L);
-  /* SWIG's internal initalisation */
-  SWIG_InitializeModule((void*)L);
-  SWIG_PropagateClientData();
-#endif
-
-#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC))
-  /* add a global fn */
-  SWIG_Lua_add_function(L,"swig_type",SWIG_Lua_type);
-  SWIG_Lua_add_function(L,"swig_equals",SWIG_Lua_equal);
-  /* begin the module (its a table with the same name as the module) */
-  SWIG_Lua_module_begin(L,SWIG_name);
-  /* add commands/functions */
-  for (i = 0; swig_commands[i].name; i++){
-    SWIG_Lua_module_add_function(L,swig_commands[i].name,swig_commands[i].func);
-  }
-  /* add variables */
-  for (i = 0; swig_variables[i].name; i++){
-    SWIG_Lua_module_add_variable(L,swig_variables[i].name,swig_variables[i].get,swig_variables[i].set);
-  }
-#endif
-
-#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
-  /* set up base class pointers (the hierarchy) */
-  for (i = 0; swig_types[i]; i++){
-    if (swig_types[i]->clientdata){
-      SWIG_Lua_init_base_class(L,(swig_lua_class*)(swig_types[i]->clientdata));
-    }
-  }
-  /* additional registration structs & classes in lua */
-  for (i = 0; swig_types[i]; i++){
-    if (swig_types[i]->clientdata){
-      SWIG_Lua_class_register(L,(swig_lua_class*)(swig_types[i]->clientdata));
-    }
-  }
-#endif
-
-#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC))
-  /* constants */
-  SWIG_Lua_InstallConstants(L,swig_constants);
-#endif
-
-#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
-  /* invoke user-specific initialization */
-  SWIG_init_user(L);
-  /* end module */
-  /* Note: We do not clean up the stack here (Lua will do this for us). At this
-     point, we have the globals table and out module table on the stack. Returning
-     one value makes the module table the result of the require command. */
-  return 1;
-#else
-  return 0;
-#endif
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-%}
-
-/* Note: the initialization function is closed after all code is generated */
-
diff --git a/share/swig/2.0.11/lua/luatypemaps.swg b/share/swig/2.0.11/lua/luatypemaps.swg
deleted file mode 100644
index f6791a2..0000000
--- a/share/swig/2.0.11/lua/luatypemaps.swg
+++ /dev/null
@@ -1,389 +0,0 @@
-/* -----------------------------------------------------------------------------
- * luatypemaps.swg
- *
- * basic typemaps for Lua.
- * ----------------------------------------------------------------------------- */
-
-/* -----------------------------------------------------------------------------
- *                          standard typemaps
- * ----------------------------------------------------------------------------- */
-/* NEW LANGUAGE NOTE:
-   the 'checkfn' param is something that I added for typemap(in)
-   it is an optional fn call to check the type of the lua object
-   the fn call must be of the form
-     int checkfn(lua_State *L, int index);
-   and return 1/0 depending upon if this is the correct type
-   For the typemap(out), an additional SWIG_arg parameter must be incremented
-   to reflect the number of values returned (normally SWIG_arg++; will do)
-*/
-// numbers
-%typemap(in,checkfn="lua_isnumber") int, short, long,
-             signed char, float, double
-%{$1 = ($type)lua_tonumber(L, $input);%}
- 
-// additional check for unsigned numbers, to not permit negative input
-%typemap(in,checkfn="lua_isnumber") unsigned int,
-             unsigned short, unsigned long, unsigned char
-%{SWIG_contract_assert((lua_tonumber(L,$input)>=0),"number must not be negative")
-$1 = ($type)lua_tonumber(L, $input);%}
-
-%typemap(out) int,short,long,
-             unsigned int,unsigned short,unsigned long,
-             signed char,unsigned char,
-             float,double
-%{  lua_pushnumber(L, (lua_Number) $1); SWIG_arg++;%}
-
-// we must also provide typemaps for primitives by const reference:
-// given a function:
-//	int intbyref(const int& i);
-// SWIG assumes that this code will need a pointer to int to be passed in
-// (this might be ok for objects by const ref, but not for numeric primitives)
-// therefore we add a set of typemaps to fix this (for both in & out)
-%typemap(in,checkfn="lua_isnumber") const int&($basetype temp)
-%{ temp=($basetype)lua_tonumber(L,$input); $1=&temp;%}
-
-%typemap(in,checkfn="lua_isnumber") const unsigned int&($basetype temp)
-%{SWIG_contract_assert((lua_tonumber(L,$input)>=0),"number must not be negative")
-temp=($basetype)lua_tonumber(L,$input); $1=&temp;%}
-
-%typemap(out) const int&, const unsigned int&
-%{  lua_pushnumber(L, (lua_Number) *$1); SWIG_arg++;%}
-
-// for the other numbers we can just use an apply statement to cover them
-%apply const int & {const short&,const long&,const signed char&,
-             const float&,const double&};
-
-%apply const unsigned int & {const unsigned short&,const unsigned long&,
-             const unsigned char&};
-
-/* enums have to be handled slightly differently
-	VC++ .net will not allow a cast from lua_Number(double) to enum directly.
-*/
-%typemap(in,checkfn="lua_isnumber") enum SWIGTYPE
-%{$1 = ($type)(int)lua_tonumber(L, $input);%}
-
-%typemap(out) enum SWIGTYPE
-%{  lua_pushnumber(L, (lua_Number)(int)($1)); SWIG_arg++;%}
-
-// and const refs
-%typemap(in,checkfn="lua_isnumber") const enum SWIGTYPE &($basetype temp)
-%{ temp=($basetype)(int)lua_tonumber(L,$input); $1=&temp;%}
-%typemap(out) const enum SWIGTYPE &
-%{  lua_pushnumber(L, (lua_Number) *$1); SWIG_arg++;%}
-
-
-// boolean (which is a special type in lua)
-// note: lua_toboolean() returns 1 or 0
-// note: 1 & 0 are not booleans in lua, only true & false
-%typemap(in,checkfn="lua_isboolean") bool
-%{$1 = (lua_toboolean(L, $input)!=0);%}
-
-%typemap(out) bool
-%{  lua_pushboolean(L,(int)($1!=0)); SWIG_arg++;%}
-
-// for const bool&, SWIG treats this as a const bool* so we must dereference it
-%typemap(in,checkfn="lua_isboolean") const bool& (bool temp)
-%{temp=(lua_toboolean(L, $input)!=0);
-  $1=&temp;%}
-
-%typemap(out) const bool&
-%{  lua_pushboolean(L,(int)((*$1)!=0)); SWIG_arg++;%}
-
-// strings (char * and char[])
-%fragment("SWIG_lua_isnilstring", "header") {
-SWIGINTERN int SWIG_lua_isnilstring(lua_State *L, int idx) {
-  int ret = lua_isstring(L, idx);
-  if (!ret)
-   ret = lua_isnil(L, idx);
-  return ret;
-}
-}
-
-%typemap(in,checkfn="SWIG_lua_isnilstring",fragment="SWIG_lua_isnilstring") const char *, char *
-%{$1 = ($ltype)lua_tostring(L, $input);%}
-
-%typemap(in,checkfn="SWIG_lua_isnilstring",fragment="SWIG_lua_isnilstring") const char[ANY], char[ANY]
-%{$1 = ($ltype)lua_tostring(L, $input);%}
-
-%typemap(out) const char *, char *
-%{  lua_pushstring(L,(const char *)$1); SWIG_arg++;%}
-
-%typemap(out) const char[ANY], char[ANY]
-%{  lua_pushstring(L,(const char *)$1); SWIG_arg++;%}
-
-// char's
-// currently treating chars as small strings, not as numbers
-// (however signed & unsigned char's are numbers...)
-%typemap(in,checkfn="SWIG_lua_isnilstring",fragment="SWIG_lua_isnilstring") char
-%{$1 = (lua_tostring(L, $input))[0];%}
-
-%typemap(out) char
-%{  lua_pushfstring(L,"%c",$1); SWIG_arg++;%}
-
-// by const ref
-%typemap(in,checkfn="SWIG_lua_isnilstring",fragment="SWIG_lua_isnilstring") const char& (char temp)
-%{temp = (lua_tostring(L, $input))[0]; $1=&temp;%}
-
-%typemap(out) const char&
-%{  lua_pushfstring(L,"%c",*$1); SWIG_arg++;%}
-
-// pointers and references
-// under SWIG rules, it is ok, to have a pass in a lua nil,
-// it should be converted to a SWIG NULL.
-// This will only be allowed for pointers & arrays, not refs or by value
-// the checkfn lua_isuserdata will only work for userdata
-// the checkfn SWIG_isptrtype will work for both userdata and nil
-%typemap(in,checkfn="SWIG_isptrtype") SWIGTYPE*,SWIGTYPE[]
-%{
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,$input,(void**)&$1,$descriptor,$disown))){
-    SWIG_fail_ptr("$symname",$argnum,$descriptor);
-  }
-%}
-
-%typemap(in,checkfn="lua_isuserdata") SWIGTYPE&
-%{
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,$input,(void**)&$1,$descriptor,$disown))){
-    SWIG_fail_ptr("$symname",$argnum,$descriptor);
-  }
-%}
-
-// out is simple
-%typemap(out) SWIGTYPE*,SWIGTYPE&
-%{SWIG_NewPointerObj(L,$1,$descriptor,$owner); SWIG_arg++; %}
-
-// dynamic casts
-// this uses the SWIG_TypeDynamicCast() which relies on RTTI to find out what the pointer really is
-// the we return it as the correct type
-%typemap(out) SWIGTYPE *DYNAMIC,
-              SWIGTYPE &DYNAMIC
-{
-  swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor, (void **) &$1);
-  SWIG_NewPointerObj(L,(void*)$1,ty,$owner); SWIG_arg++; 
-}
-
-
-// passing objects by value
-// SWIG_ConvertPtr wants an object pointer (the $&ltype argp)
-// then dereferences it to get the object
-%typemap(in,checkfn="lua_isuserdata") SWIGTYPE ($&ltype argp)
-%{
-   if (!SWIG_IsOK(SWIG_ConvertPtr(L,$input,(void**)&argp,$&descriptor,0))){
-     SWIG_fail_ptr("$symname",$argnum,$&descriptor);
-   }
-   $1 = *argp;
-%}
-
-// Also needed for object ptrs by const ref
-// eg A* const& ref_pointer(A* const& a);
-// found in mixed_types.i
-%typemap(in,checkfn="lua_isuserdata") SWIGTYPE *const&($*ltype temp)
-%{temp=($*ltype)SWIG_MustGetPtr(L,$input,$*descriptor,0,$argnum,"$symname");
-$1=($1_ltype)&temp;%}
-
-%typemap(out) SWIGTYPE *const&
-%{SWIG_NewPointerObj(L,*$1,$*descriptor,$owner); SWIG_arg++; %}
-
-
-// DISOWN-ing typemaps
-// if you have an object pointer which must be disowned, use this typemap
-// eg. for void destroy_foo(Foo* toDie);
-// use %apply SWIGTYPE* DISOWN {Foo* toDie};
-// you could just use %delobject, but this is more flexible
-%typemap(in,checkfn="SWIG_isptrtype") SWIGTYPE* DISOWN,SWIGTYPE DISOWN[]
-%{  if (!SWIG_IsOK(SWIG_ConvertPtr(L,$input,(void**)&$1,$descriptor,SWIG_POINTER_DISOWN))){
-    SWIG_fail_ptr("$symname",$argnum,$descriptor);
-  }
-%}
-
-
-// Primitive types--return by value
-// must make a new object, copy the data & return the new object
-// Note: the brackets are {...} and not %{..%}, because we want them to be included in the wrapper
-// this is because typemap(out) does not support local variables, like in typemap(in) does
-// and we need the $&1_ltype resultptr; to be declared
-#ifdef __cplusplus
-%typemap(out) SWIGTYPE
-{
-  $&1_ltype resultptr = new $1_ltype((const $1_ltype &) $1);
-  SWIG_NewPointerObj(L,(void *) resultptr,$&1_descriptor,1); SWIG_arg++;
-}
-#else
-%typemap(out) SWIGTYPE
-{
-  $&1_ltype resultptr;
-  resultptr = ($&1_ltype) malloc(sizeof($1_type));
-  memmove(resultptr, &$1, sizeof($1_type));
-  SWIG_NewPointerObj(L,(void *) resultptr,$&1_descriptor,1); SWIG_arg++;
-}
-#endif
-
-// member function pointer
-// a member fn ptr is not 4 bytes like a normal pointer, but 8 bytes (at least on mingw)
-// so the standard wrapping cannot be done
-// nor can you cast a member function pointer to a void* (obviously)
-// therefore a special wrapping functions SWIG_ConvertMember() & SWIG_NewMemberObj() were written
-#ifdef __cplusplus
-%typemap(in,checkfn="lua_isuserdata") SWIGTYPE (CLASS::*)
-%{
-  if (!SWIG_IsOK(SWIG_ConvertMember(L,$input,(void*)(&$1),sizeof($type),$descriptor)))
-    SWIG_fail_ptr("$symname",$argnum,$descriptor);
-%}
-
-%typemap(out) SWIGTYPE (CLASS::*)
-%{ 
-  SWIG_NewMemberObj(L,(void*)(&$1),sizeof($type),$descriptor); SWIG_arg++; 
-%}
-#endif
-
-
-// void (must be empty without the SWIG_arg++)
-%typemap(out) void "";
-
-/* void* is a special case
-A function void fn(void*) should take any kind of pointer as a parameter (just like C/C++ does)
-but if its an output, then it should be wrapped like any other SWIG object (using default typemap)
-*/
-%typemap(in,checkfn="SWIG_isptrtype") void*
-%{$1=($1_ltype)SWIG_MustGetPtr(L,$input,0,0,$argnum,"$symname");%}
-
-/* long long is another special case:
-as lua only supports one numeric type (lua_Number), we will just
-cast it to that & accept the loss of precision.
-An alternative solution would be a long long struct or class
-with the relevant operators.
-*/
-%apply long {long long, signed long long, unsigned long long};
-%apply const long& {const long long&, const signed long long&, const unsigned long long&};
-
-/* It is possible to also pass a lua_State* into a function, so
-void fn(int a, float b, lua_State* s) is wrappable as
-> fn(1,4.3) -- note: the state is implicitly passed in
-*/
-%typemap(in, numinputs=0) lua_State* 
-%{$1 = L;%}
-
-
-
-/* -----------------------------------------------------------------------------
- *                          typecheck rules
- * ----------------------------------------------------------------------------- */
-/* These are needed for the overloaded functions
-These define the detection routines which will spot what
-parameters match which function
-*/
-
-// unfortunately lua only considers one type of number
-// so all numbers (int,float,double) match
-// you could add an advanced fn to get type & check if its integral
-%typecheck(SWIG_TYPECHECK_INTEGER)
-	 int, short, long,
- 	 unsigned int, unsigned short, unsigned long,
-	 signed char, unsigned char,
-	 long long, unsigned long long, signed long long,
-	 const int &, const short &, const long &,
- 	 const unsigned int &, const unsigned short &, const unsigned long &,
-	 const signed char&, const unsigned char&,
-	 const long long &, const unsigned long long &,
-	 enum SWIGTYPE,	const enum SWIGTYPE&,
-	 float, double, const float &, const double&
-{
-  $1 = lua_isnumber(L,$input);
-}
-
-%typecheck(SWIG_TYPECHECK_BOOL)
-    bool, const bool &
-{
-  $1 = lua_isboolean(L,$input);
-}
-
-// special check for a char (string of length 1)
-%typecheck(SWIG_TYPECHECK_CHAR,fragment="SWIG_lua_isnilstring") char, const char& {
-  $1 = SWIG_lua_isnilstring(L,$input) && (lua_rawlen(L,$input)==1);
-}
-
-%typecheck(SWIG_TYPECHECK_STRING,fragment="SWIG_lua_isnilstring") char *, char[] {
-  $1 = SWIG_lua_isnilstring(L,$input);
-}
-
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE [] {
-  void *ptr;
-  if (SWIG_isptrtype(L,$input)==0 || SWIG_ConvertPtr(L,$input, (void **) &ptr, $1_descriptor, 0)) {
-    $1 = 0;
-  } else {
-    $1 = 1;
-  }
-}
-
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE & {
-  void *ptr;
-  if (lua_isuserdata(L,$input)==0 || SWIG_ConvertPtr(L,$input, (void **) &ptr, $1_descriptor, 0)) {
-    $1 = 0;
-  } else {
-    $1 = 1;
-  }
-}
-
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE {
-  void *ptr;
-  if (lua_isuserdata(L,$input)==0 || SWIG_ConvertPtr(L,$input, (void **) &ptr, $&1_descriptor, 0)) {
-    $1 = 0;
-  } else {
-    $1 = 1;
-  }
-}
-
-%typecheck(SWIG_TYPECHECK_VOIDPTR) void * {
-  void *ptr;
-  if (SWIG_isptrtype(L,$input)==0 || SWIG_ConvertPtr(L,$input, (void **) &ptr, 0, 0)) {
-    $1 = 0;
-  } else {
-    $1 = 1;
-  }
-}
-
-// Also needed for object pointers by const ref
-// eg const A* ref_pointer(A* const& a);
-// found in mixed_types.i
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *const&
-{
-  void *ptr;
-  if (lua_isuserdata(L,$input)==0 || SWIG_ConvertPtr(L,$input, (void **) &ptr, $*descriptor, 0)) {
-    $1 = 0;
-  } else {
-    $1 = 1;
-  }
-}
-
-/* -----------------------------------------------------------------------------
- *                          Others
- * ----------------------------------------------------------------------------- */
-
-// Array reference typemaps
-%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
-
-/* const pointers */
-%apply SWIGTYPE * { SWIGTYPE *const }
-
-// size_t (which is just a unsigned long)
-%apply unsigned long { size_t };
-%apply const unsigned long & { const size_t & };
-
-
-/* -----------------------------------------------------------------------------
- *                          Specials
- * ----------------------------------------------------------------------------- */
-// swig::LANGUAGE_OBJ was added to allow containers of native objects
-// however its rather difficult to do this in lua, as you cannot hold pointers
-// to native objects (they are held in the interpreter)
-// therefore for now: just ignoring this feature
-#ifdef __cplusplus
-%ignore swig::LANGUAGE_OBJ;
-
-//%inline %{
-%{
-namespace swig {
-typedef struct{} LANGUAGE_OBJ;
-}
-%}
-
-#endif // __cplusplus
diff --git a/share/swig/2.0.11/lua/std_except.i b/share/swig/2.0.11/lua/std_except.i
deleted file mode 100644
index 1608287..0000000
--- a/share/swig/2.0.11/lua/std_except.i
+++ /dev/null
@@ -1,40 +0,0 @@
-/* -----------------------------------------------------------------------------
- * 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);
- *
- * std_except.i
- * ----------------------------------------------------------------------------- */
-
-%{
-#include <stdexcept>
-%}
-%include <exception.i>
-
-namespace std 
-{
-  %ignore exception; // not sure if I should ignore this...
-  class exception 
-  {
-  public:
-    exception() throw() { }
-    virtual ~exception() throw();
-    virtual const char* what() const throw();
-  }; 
-}
-
-// normally objects which are thrown are returned to the interpreter as errors
-// (which potentially may have problems if they are not copied)
-// therefore all classes based upon std::exception are converted to their strings & returned as errors
-%typemap(throws) std::bad_exception     "SWIG_exception(SWIG_RuntimeError, $1.what());"
-%typemap(throws) std::domain_error      "SWIG_exception(SWIG_ValueError, $1.what());"
-%typemap(throws) std::exception         "SWIG_exception(SWIG_SystemError, $1.what());"
-%typemap(throws) std::invalid_argument  "SWIG_exception(SWIG_ValueError, $1.what());"
-%typemap(throws) std::length_error      "SWIG_exception(SWIG_IndexError, $1.what());"
-%typemap(throws) std::logic_error       "SWIG_exception(SWIG_RuntimeError, $1.what());"
-%typemap(throws) std::out_of_range      "SWIG_exception(SWIG_IndexError, $1.what());"
-%typemap(throws) std::overflow_error    "SWIG_exception(SWIG_OverflowError, $1.what());"
-%typemap(throws) std::range_error       "SWIG_exception(SWIG_IndexError, $1.what());"
-%typemap(throws) std::runtime_error     "SWIG_exception(SWIG_RuntimeError, $1.what());"
-%typemap(throws) std::underflow_error   "SWIG_exception(SWIG_RuntimeError, $1.what());"
diff --git a/share/swig/2.0.11/lua/typemaps.i b/share/swig/2.0.11/lua/typemaps.i
deleted file mode 100644
index 7a095a1..0000000
--- a/share/swig/2.0.11/lua/typemaps.i
+++ /dev/null
@@ -1,564 +0,0 @@
-/* -----------------------------------------------------------------------------
- * typemaps.swg
- *
- * SWIG Library file containing the main typemap code to support Lua modules.
- * ----------------------------------------------------------------------------- */
-
-/* -----------------------------------------------------------------------------
- *                          Basic inout typemaps
- * ----------------------------------------------------------------------------- */
-/*
-These provide the basic ability for passing in & out of standard numeric data types
-(int,long,float,double, etc)
-
-The basic code looks like this:
-
-%typemap(in,checkfn="lua_isnumber") int *INPUT(int temp), int &INPUT(int temp)
-%{ temp = (int)lua_tonumber(L,$input);
-   $1 = &temp; %}
-
-%typemap(in, numinputs=0) int *OUTPUT (int temp)
-%{ $1 = &temp; %}
-
-%typemap(argout) int *OUTPUT
-%{  lua_pushnumber(L, (double) *$1); SWIG_arg++;%}
-
-%typemap(in) int *INOUT = int *INPUT;
-%typemap(argout) int *INOUT = int *OUTPUT;
-
-However the code below is a mixture of #defines & such, so nowhere as easy to read
-
-To make you code work correctly its not just a matter of %including this file
-You also have to give SWIG the hints on which to use where
-
-eg
-extern int add_pointer(int* a1,int* a2); // a1 & a2 are pointer values to be added
-extern void swap(int* s1, int* s2);	// does the swap
-
-You will need to either change the argument names
-extern int add_pointer(int* INPUT,int* INPUT);
-
-or provide a %apply statement
-
-%apply int* INOUT{ int *s1, int *s2 };
-	// if SWIG sees int* s1, int* s2, assume they are inout params
-*/
-
-
-%define SWIG_NUMBER_TYPEMAP(TYPE)
-%typemap(in,checkfn="lua_isnumber")	TYPE *INPUT($*ltype temp), TYPE &INPUT($*ltype temp)
-%{ temp = ($*ltype)lua_tonumber(L,$input);
-   $1 = &temp; %}
-%typemap(in, numinputs=0) TYPE *OUTPUT ($*ltype temp)
-%{ $1 = &temp; %}
-%typemap(argout) TYPE *OUTPUT
-%{  lua_pushnumber(L, (lua_Number) *$1); SWIG_arg++;%}
-%typemap(in) TYPE *INOUT = TYPE *INPUT;
-%typemap(argout) TYPE *INOUT = TYPE *OUTPUT;
-%typemap(in) TYPE &OUTPUT = TYPE *OUTPUT;
-%typemap(argout) TYPE &OUTPUT = TYPE *OUTPUT;
-%typemap(in) TYPE &INOUT = TYPE *INPUT;
-%typemap(argout) TYPE &INOUT = TYPE *OUTPUT;
-// const version (the $*ltype is the basic number without ptr or const's)
-%typemap(in,checkfn="lua_isnumber")	const TYPE *INPUT($*ltype temp)
-%{ temp = ($*ltype)lua_tonumber(L,$input);
-   $1 = &temp; %}
-%enddef
-
-// now the code
-SWIG_NUMBER_TYPEMAP(unsigned char); SWIG_NUMBER_TYPEMAP(signed char);
-
-SWIG_NUMBER_TYPEMAP(short); SWIG_NUMBER_TYPEMAP(unsigned short); SWIG_NUMBER_TYPEMAP(signed short);
-SWIG_NUMBER_TYPEMAP(int); SWIG_NUMBER_TYPEMAP(unsigned int); SWIG_NUMBER_TYPEMAP(signed int);
-SWIG_NUMBER_TYPEMAP(long); SWIG_NUMBER_TYPEMAP(unsigned long); SWIG_NUMBER_TYPEMAP(signed long);
-SWIG_NUMBER_TYPEMAP(float);
-SWIG_NUMBER_TYPEMAP(double);
-SWIG_NUMBER_TYPEMAP(enum SWIGTYPE);
-// also for long longs's
-SWIG_NUMBER_TYPEMAP(long long); SWIG_NUMBER_TYPEMAP(unsigned long long); SWIG_NUMBER_TYPEMAP(signed long long);
-
-// note we dont do char, as a char* is probably a string not a ptr to a single char
-
-// similar for booleans
-%typemap(in,checkfn="lua_isboolean") bool *INPUT(bool temp), bool &INPUT(bool temp)
-%{ temp = (lua_toboolean(L,$input)!=0);
-   $1 = &temp; %}
-
-%typemap(in, numinputs=0) bool *OUTPUT (bool temp),bool &OUTPUT (bool temp)
-%{ $1 = &temp; %}
-
-%typemap(argout) bool *OUTPUT,bool &OUTPUT
-%{  lua_pushboolean(L, (int)((*$1)!=0)); SWIG_arg++;%}
-
-%typemap(in) bool *INOUT = bool *INPUT;
-%typemap(argout) bool *INOUT = bool *OUTPUT;
-%typemap(in) bool &INOUT = bool &INPUT;
-%typemap(argout) bool &INOUT = bool &OUTPUT;
-
-/* -----------------------------------------------------------------------------
- *                          Basic Array typemaps
- * ----------------------------------------------------------------------------- */
-/*
-I have no idea why this kind of code does not exist in SWIG as standard,
-but here is it.
-This code will convert to/from 1D numeric arrays.
-In order to reduce code bloat, there are a few macros
-and quite a few functions defined
-(unfortunately this makes it a lot less clear)
-
-assuming we have functions
-void process_array(int arr[3]);	// nice fixed size array
-void process_var_array(float arr[],int len);	// variable sized array
-void process_var_array_inout(double* arr,int len);	// variable sized array
-			// data passed in & out
-void process_enum_inout_array_var(enum Days *arrinout, int len);	// using enums
-void return_array_5(int arrout[5]);	// out array only
-
-in order to wrap them correctly requires a typemap
-
-// inform SWIG of the correct typemap
-// For fixed length, you must specify it as <type> INPUT[ANY]
-%apply (int INPUT[ANY]) {(int arr[3])};
-// variable length arrays are just the same
-%apply (float INPUT[],int) {(float arr[],int len)};
-// it is also ok, to map the TYPE* instead of a TYPE[]
-%apply (double *INOUT,int) {(double arr*,int len)};
-// for the enum's you must use enum SWIGTYPE
-%apply (enum SWIGTYPE *INOUT,int) {(enum Days *arrinout, int len)};
-// fixed length out if also fine
-%apply (int OUTPUT[ANY]) {(int arrout[5])};
-
-Generally, you could use %typemap(...)=...
-but the %apply is neater & easier
-
-a few things of note:
-* all Lua tables are indexed from 1, all C/C++ arrays are indexed from 0
-	therefore t={6,5,3} -- t[1]==6, t[2]==5, t[3]==3
-	when passed to process_array(int arr[3]) becomes
-	arr[0]==6, arr[1]==5, arr[2]==3
-* for OUTPUT arrays, no array need be passed in, the fn will return a Lua table
-	so for the above mentioned return_array_5() would look like
-	arr=return_array_5() -- no parameters passed in
-* for INOUT arrays, a table must be passed in, and a new table will be returned
-	(this is consistent with the way that numbers are processed)
-	if you want just use
-	arr={...}
-	arr=process_var_array_inout(arr)	-- arr is replaced by the new version
-
-The following are not yet supported:
-* variable length output only array (inout works ok)
-* multidimensional arrays
-* arrays of objects/structs
-* arrays of pointers
-
-*/
-
-/*
-The internals of the array management stuff
-helper fns/macros
-SWIG_ALLOC_ARRAY(TYPE,LEN)	// returns a typed array TYPE[LEN]
-SWIG_FREE_ARRAY(PTR)		// delete the ptr (if not zero)
-
-// counts the specified table & gets the size
-// integer version
-int SWIG_itable_size(lua_State* L, int index);
-// other version
-int SWIG_table_size(lua_State* L, int index);
-
-SWIG_DECLARE_TYPEMAP_ARR_FN(NAME,TYPE)
-// this fn declares up 4 functions for helping to read/write tables
-// these can then be called by the macros ...
-// all assume the table is an integer indexes from 1
-// but the C array is a indexed from 0
-	// created a fixed size array, reads the specified table
-	// and then fills the array with numbers
-	// returns ptr to the array if ok, or 0 for error
-	// (also pushes a error message to the stack)
-TYPE* SWIG_get_NAME_num_array_fixed(lua_State* L, int index, int size);
-	// as per SWIG_get_NAME_num_array_fixed()
-	// but reads the entire table & creates an array of the correct size
-	// (if the table is empty, it returns an error rather than a zero length array)
-TYPE* SWIG_get_NAME_num_array_var(lua_State* L, int index, int* size);
-	// writes a table to Lua with all the specified numbers
-void SWIG_write_NAME_num_array(lua_State* L,TYPE *array,int size);
-	// read the specified table, and fills the array with numbers
-	// returns 1 of ok (only fails if it doesnt find numbers)
-	// helper fn (called by SWIG_get_NAME_num_array_*() fns)
-int SWIG_read_NAME_num_array(lua_State* L,int index,TYPE *array,int size);
-
-*/
-
-/* Reported that you don't need to check for NULL for delete & free
-There probably is some compiler that its not true for, so the code is left here just in case.
-#ifdef __cplusplus	
-#define SWIG_ALLOC_ARRAY(TYPE,LEN) 	new TYPE[LEN]
-#define SWIG_FREE_ARRAY(PTR)		if(PTR){delete[] PTR;}
-#else
-#define SWIG_ALLOC_ARRAY(TYPE,LEN) 	(TYPE *)malloc(LEN*sizeof(TYPE))
-#define SWIG_FREE_ARRAY(PTR)		if(PTR){free(PTR);}
-#endif
-*/
-%{
-#ifdef __cplusplus	/* generic alloc/dealloc fns*/
-#define SWIG_ALLOC_ARRAY(TYPE,LEN) 	new TYPE[LEN]
-#define SWIG_FREE_ARRAY(PTR)		delete[] PTR
-#else
-#define SWIG_ALLOC_ARRAY(TYPE,LEN) 	(TYPE *)malloc(LEN*sizeof(TYPE))
-#define SWIG_FREE_ARRAY(PTR)		free(PTR)
-#endif
-/* counting the size of arrays:*/
-SWIGINTERN int SWIG_itable_size(lua_State* L, int index)
-{
-	int n=0;
-	while(1){
-		lua_rawgeti(L,index,n+1);
-		if (lua_isnil(L,-1))break;
-		++n;
-		lua_pop(L,1);
-	}
-	lua_pop(L,1);
-	return n;
-}
-
-SWIGINTERN int SWIG_table_size(lua_State* L, int index)
-{
-	int n=0;
-	lua_pushnil(L);  /* first key*/
-	while (lua_next(L, index) != 0) {
-		++n;
-		lua_pop(L, 1);  /* removes `value'; keeps `key' for next iteration*/
-	}
-	return n;
-}
-
-/* super macro to declare array typemap helper fns */
-#define SWIG_DECLARE_TYPEMAP_ARR_FN(NAME,TYPE)\
-	SWIGINTERN int SWIG_read_##NAME##_num_array(lua_State* L,int index,TYPE *array,int size){\
-		int i;\
-		for (i = 0; i < size; i++) {\
-			lua_rawgeti(L,index,i+1);\
-			if (lua_isnumber(L,-1)){\
-				array[i] = (TYPE)lua_tonumber(L,-1);\
-			} else {\
-				lua_pop(L,1);\
-				return 0;\
-			}\
-			lua_pop(L,1);\
-		}\
-		return 1;\
-	}\
-	SWIGINTERN TYPE* SWIG_get_##NAME##_num_array_fixed(lua_State* L, int index, int size){\
-		TYPE *array;\
-		if (!lua_istable(L,index) || SWIG_itable_size(L,index) != size) {\
-			SWIG_Lua_pushferrstring(L,"expected a table of size %d",size);\
-			return 0;\
-		}\
-		array=SWIG_ALLOC_ARRAY(TYPE,size);\
-		if (!SWIG_read_##NAME##_num_array(L,index,array,size)){\
-			SWIG_Lua_pusherrstring(L,"table must contain numbers");\
-			SWIG_FREE_ARRAY(array);\
-			return 0;\
-		}\
-		return array;\
-	}\
-	SWIGINTERN TYPE* SWIG_get_##NAME##_num_array_var(lua_State* L, int index, int* size)\
-	{\
-		TYPE *array;\
-		if (!lua_istable(L,index)) {\
-			SWIG_Lua_pusherrstring(L,"expected a table");\
-			return 0;\
-		}\
-		*size=SWIG_itable_size(L,index);\
-		if (*size<1){\
-			SWIG_Lua_pusherrstring(L,"table appears to be empty");\
-			return 0;\
-		}\
-		array=SWIG_ALLOC_ARRAY(TYPE,*size);\
-		if (!SWIG_read_##NAME##_num_array(L,index,array,*size)){\
-			SWIG_Lua_pusherrstring(L,"table must contain numbers");\
-			SWIG_FREE_ARRAY(array);\
-			return 0;\
-		}\
-		return array;\
-	}\
-	SWIGINTERN void SWIG_write_##NAME##_num_array(lua_State* L,TYPE *array,int size){\
-		int i;\
-		lua_newtable(L);\
-		for (i = 0; i < size; i++){\
-			lua_pushnumber(L,(lua_Number)array[i]);\
-			lua_rawseti(L,-2,i+1);/* -1 is the number, -2 is the table*/ \
-		}\
-	}
-%}
-
-/*
-This is one giant macro to define the typemaps & the helpers
-for array handling
-*/
-%define SWIG_TYPEMAP_NUM_ARR(NAME,TYPE)
-%{SWIG_DECLARE_TYPEMAP_ARR_FN(NAME,TYPE);%}
-
-// fixed size array's
-%typemap(in) TYPE INPUT[ANY]
-%{	$1 = SWIG_get_##NAME##_num_array_fixed(L,$input,$1_dim0);
-	if (!$1) SWIG_fail;%}
-
-%typemap(freearg) TYPE INPUT[ANY]
-%{	SWIG_FREE_ARRAY($1);%}
-
-// variable size array's
-%typemap(in) (TYPE *INPUT,int)
-%{	$1 = SWIG_get_##NAME##_num_array_var(L,$input,&$2);
-	if (!$1) SWIG_fail;%}
-
-%typemap(freearg) (TYPE *INPUT,int)
-%{	SWIG_FREE_ARRAY($1);%}
-
-// out fixed arrays
-%typemap(in,numinputs=0) TYPE OUTPUT[ANY]
-%{  $1 = SWIG_ALLOC_ARRAY(TYPE,$1_dim0); %}
-
-%typemap(argout) TYPE OUTPUT[ANY]
-%{	SWIG_write_##NAME##_num_array(L,$1,$1_dim0); SWIG_arg++; %}
-
-%typemap(freearg) TYPE OUTPUT[ANY]
-%{	SWIG_FREE_ARRAY($1); %}
-
-// inout fixed arrays
-%typemap(in) TYPE INOUT[ANY]=TYPE INPUT[ANY];
-%typemap(argout) TYPE INOUT[ANY]=TYPE OUTPUT[ANY];
-%typemap(freearg) TYPE INOUT[ANY]=TYPE INPUT[ANY];
-// inout variable arrays
-%typemap(in) (TYPE *INOUT,int)=(TYPE *INPUT,int);
-%typemap(argout) (TYPE *INOUT,int)
-%{	SWIG_write_##NAME##_num_array(L,$1,$2); SWIG_arg++; %}
-%typemap(freearg) (TYPE *INOUT,int)=(TYPE *INPUT,int);
-
-// TODO out variable arrays (is there a standard form for such things?)
-
-// referencing so that (int *INPUT,int) and (int INPUT[],int) are the same
-%typemap(in) (TYPE INPUT[],int)=(TYPE *INPUT,int);
-%typemap(freearg) (TYPE INPUT[],int)=(TYPE *INPUT,int);
-
-%enddef
-
-// the following line of code
-// declares the C helper fns for the array typemaps
-// as well as defining typemaps for
-// fixed len arrays in & out, & variable length arrays in
-
-SWIG_TYPEMAP_NUM_ARR(schar,signed char);
-SWIG_TYPEMAP_NUM_ARR(uchar,unsigned char);
-SWIG_TYPEMAP_NUM_ARR(int,int);
-SWIG_TYPEMAP_NUM_ARR(uint,unsigned int);
-SWIG_TYPEMAP_NUM_ARR(short,short);
-SWIG_TYPEMAP_NUM_ARR(ushort,unsigned short);
-SWIG_TYPEMAP_NUM_ARR(long,long);
-SWIG_TYPEMAP_NUM_ARR(ulong,unsigned long);
-SWIG_TYPEMAP_NUM_ARR(float,float);
-SWIG_TYPEMAP_NUM_ARR(double,double);
-
-// again enums are a problem so they need their own type
-// we use the int conversion routine & recast it
-%typemap(in) enum SWIGTYPE INPUT[ANY]
-%{	$1 = ($ltype)SWIG_get_int_num_array_fixed(L,$input,$1_dim0);
-	if (!$1) SWIG_fail;%}
-
-%typemap(freearg) enum SWIGTYPE INPUT[ANY]
-%{	SWIG_FREE_ARRAY($1);%}
-
-// variable size arrays
-%typemap(in) (enum SWIGTYPE *INPUT,int)
-%{	$1 = ($ltype)SWIG_get_int_num_array_var(L,$input,&$2);
-	if (!$1) SWIG_fail;%}
-
-%typemap(freearg) (enum SWIGTYPE *INPUT,int)
-%{	SWIG_FREE_ARRAY($1);%}
-
-// out fixed arrays
-%typemap(in,numinputs=0) enum SWIGTYPE OUTPUT[ANY]
-%{  $1 = SWIG_ALLOC_ARRAY(enum SWIGTYPE,$1_dim0); %}
-
-%typemap(argout) enum SWIGTYPE OUTPUT[ANY]
-%{	SWIG_write_int_num_array(L,(int*)$1,$1_dim0); SWIG_arg++; %}
-
-%typemap(freearg) enum SWIGTYPE OUTPUT[ANY]
-%{	SWIG_FREE_ARRAY($1); %}
-
-// inout fixed arrays
-%typemap(in) enum SWIGTYPE INOUT[ANY]=enum SWIGTYPE INPUT[ANY];
-%typemap(argout) enum SWIGTYPE INOUT[ANY]=enum SWIGTYPE OUTPUT[ANY];
-%typemap(freearg) enum SWIGTYPE INOUT[ANY]=enum SWIGTYPE INPUT[ANY];
-// inout variable arrays
-%typemap(in) (enum SWIGTYPE *INOUT,int)=(enum SWIGTYPE *INPUT,int);
-%typemap(argout) (enum SWIGTYPE *INOUT,int)
-%{	SWIG_write_int_num_array(L,(int*)$1,$2); SWIG_arg++; %}
-%typemap(freearg) (enum SWIGTYPE *INOUT,int)=(enum SWIGTYPE *INPUT,int);
-
-
-/* Surprisingly pointer arrays are easier:
-this is because all ptr arrays become void**
-so only a few fns are needed & a few casts
-
-The function defined are
-	// created a fixed size array, reads the specified table
-	// and then fills the array with pointers (checking the type)
-	// returns ptr to the array if ok, or 0 for error
-	// (also pushes a error message to the stack)
-void** SWIG_get_ptr_array_fixed(lua_State* L, int index, int size,swig_type_info *type);
-	// as per SWIG_get_ptr_array_fixed()
-	// but reads the entire table & creates an array of the correct size
-	// (if the table is empty, it returns an error rather than a zero length array)
-void** SWIG_get_ptr_array_var(lua_State* L, int index, int* size,swig_type_info *type);
-	// writes a table to Lua with all the specified pointers
-	// all pointers have the ownership value 'own' (normally 0)
-void SWIG_write_ptr_array(lua_State* L,void **array,int size,int own);
-	// read the specified table, and fills the array with ptrs
-	// returns 1 of ok (only fails if it doesn't find correct type of ptrs)
-	// helper fn (called by SWIG_get_ptr_array_*() fns)
-int SWIG_read_ptr_array(lua_State* L,int index,void **array,int size,swig_type_info *type);
-
-The key thing to remember is that it is assumed that there is no
-modification of pointers ownership in the arrays
-
-eg A fn:
-void pointers_in(TYPE* arr[],int len);
-will make copies of the pointer into a temp array and then pass it into the fn
-Lua does not remember that this fn held the pointers, so it is not safe to keep
-these pointers until later
-
-eg A fn:
-void pointers_out(TYPE* arr[3]);
-will return a table containing three pointers
-however these pointers are NOT owned by Lua, merely borrowed
-so if the C/C++ frees then Lua is not aware
-
-*/
-
-%{
-SWIGINTERN int SWIG_read_ptr_array(lua_State* L,int index,void **array,int size,swig_type_info *type){
-	int i;
-	for (i = 0; i < size; i++) {
-		lua_rawgeti(L,index,i+1);
-		if (!lua_isuserdata(L,-1) || SWIG_ConvertPtr(L,-1,&array[i],type,0)==-1){
-			lua_pop(L,1);
-			return 0;
-		}
-		lua_pop(L,1);
-	}
-	return 1;
-}
-SWIGINTERN void** SWIG_get_ptr_array_fixed(lua_State* L, int index, int size,swig_type_info *type){
-	void **array;
-	if (!lua_istable(L,index) || SWIG_itable_size(L,index) != size) {
-		SWIG_Lua_pushferrstring(L,"expected a table of size %d",size);
-		return 0;
-	}
-	array=SWIG_ALLOC_ARRAY(void*,size);
-	if (!SWIG_read_ptr_array(L,index,array,size,type)){
-		SWIG_Lua_pushferrstring(L,"table must contain pointers of type %s",type->name);
-		SWIG_FREE_ARRAY(array);
-		return 0;
-	}
-	return array;
-}
-SWIGINTERN void** SWIG_get_ptr_array_var(lua_State* L, int index, int* size,swig_type_info *type){
-	void **array;
-	if (!lua_istable(L,index)) {
-		SWIG_Lua_pusherrstring(L,"expected a table");
-		return 0;
-	}
-	*size=SWIG_itable_size(L,index);
-	if (*size<1){
-		SWIG_Lua_pusherrstring(L,"table appears to be empty");
-		return 0;
-	}
-	array=SWIG_ALLOC_ARRAY(void*,*size);
-	if (!SWIG_read_ptr_array(L,index,array,*size,type)){
-		SWIG_Lua_pushferrstring(L,"table must contain pointers of type %s",type->name);
-		SWIG_FREE_ARRAY(array);
-		return 0;
-	}
-	return array;
-}
-SWIGINTERN void SWIG_write_ptr_array(lua_State* L,void **array,int size,swig_type_info *type,int own){
-	int i;
-	lua_newtable(L);
-	for (i = 0; i < size; i++){
-		SWIG_NewPointerObj(L,array[i],type,own);
-		lua_rawseti(L,-2,i+1);/* -1 is the number, -2 is the table*/
-	}
-}
-%}
-
-// fixed size array's
-%typemap(in) SWIGTYPE* INPUT[ANY]
-%{	$1 = ($ltype)SWIG_get_ptr_array_fixed(L,$input,$1_dim0,$*1_descriptor);
-	if (!$1) SWIG_fail;%}
-
-%typemap(freearg) SWIGTYPE* INPUT[ANY]
-%{	SWIG_FREE_ARRAY($1);%}
-
-// variable size array's
-%typemap(in) (SWIGTYPE **INPUT,int)
-%{	$1 = ($ltype)SWIG_get_ptr_array_var(L,$input,&$2,$*1_descriptor);
-	if (!$1) SWIG_fail;%}
-
-%typemap(freearg) (SWIGTYPE **INPUT,int)
-%{	SWIG_FREE_ARRAY($1);%}
-
-// out fixed arrays
-%typemap(in,numinputs=0) SWIGTYPE* OUTPUT[ANY]
-%{  $1 = SWIG_ALLOC_ARRAY($*1_type,$1_dim0); %}
-
-%typemap(argout) SWIGTYPE* OUTPUT[ANY]
-%{	SWIG_write_ptr_array(L,(void**)$1,$1_dim0,$*1_descriptor,0); SWIG_arg++; %}
-
-%typemap(freearg) SWIGTYPE* OUTPUT[ANY]
-%{	SWIG_FREE_ARRAY($1); %}
-
-// inout fixed arrays
-%typemap(in) SWIGTYPE* INOUT[ANY]=SWIGTYPE* INPUT[ANY];
-%typemap(argout) SWIGTYPE* INOUT[ANY]=SWIGTYPE* OUTPUT[ANY];
-%typemap(freearg) SWIGTYPE* INOUT[ANY]=SWIGTYPE* INPUT[ANY];
-// inout variable arrays
-%typemap(in) (SWIGTYPE** INOUT,int)=(SWIGTYPE** INPUT,int);
-%typemap(argout) (SWIGTYPE** INOUT,int)
-%{	SWIG_write_ptr_array(L,(void**)$1,$2,$*1_descriptor,0); SWIG_arg++; %}
-%typemap(freearg) (SWIGTYPE**INOUT,int)=(SWIGTYPE**INPUT,int);
-
-/* -----------------------------------------------------------------------------
- *                          Pointer-Pointer typemaps
- * ----------------------------------------------------------------------------- */
-/*
-This code is to deal with the issue for pointer-pointer's
-In particular for factory methods.
-
-for example take the following code segment:
-
-struct iMath;    // some structure
-int Create_Math(iMath** pptr); // its factory (assume it mallocs)
-
-to use it you might have the following C code:
-
-iMath* ptr;
-int ok;
-ok=Create_Math(&ptr);
-// do things with ptr
-//...
-free(ptr);
-
-With the following SWIG code
-%apply SWIGTYPE** OUTPUT{iMath **pptr };
-
-You can get natural wrapping in Lua as follows:
-ok,ptr=Create_Math() -- ptr is a iMath* which is returned with the int
-ptr=nil -- the iMath* will be GC'ed as normal
-*/
-
-%typemap(in,numinputs=0) SWIGTYPE** OUTPUT ($*ltype temp)
-%{ temp = ($*ltype)0;
-   $1 = &temp; %}
-%typemap(argout) SWIGTYPE** OUTPUT
-%{SWIG_NewPointerObj(L,*$1,$*descriptor,1); SWIG_arg++; %}
-
diff --git a/share/swig/2.0.11/lua/wchar.i b/share/swig/2.0.11/lua/wchar.i
deleted file mode 100644
index 141ecc4..0000000
--- a/share/swig/2.0.11/lua/wchar.i
+++ /dev/null
@@ -1,42 +0,0 @@
-/* -----------------------------------------------------------------------------
- * wchar.i
- *
- * Typemaps for the wchar_t type
- * These are mapped to a Lua string and are passed around by value.
- * ----------------------------------------------------------------------------- */
-
-// note: only support for pointer right now, not fixed length strings
-// TODO: determine how long a const wchar_t* is so we can write wstr2str() 
-// & do the output typemap
-
-%{
-#include <stdlib.h>
-	
-wchar_t* str2wstr(const char *str, int len)
-{
-  wchar_t* p;
-  if (str==0 || len<1)  return 0;
-  p=(wchar *)malloc((len+1)*sizeof(wchar_t));
-  if (p==0)	return 0;
-  if (mbstowcs(p, str, len)==-1)
-  {
-    free(p);
-    return 0;
-  }
-  p[len]=0;
-  return p;
-}
-%}
-
-%typemap(in, checkfn="SWIG_lua_isnilstring", fragment="SWIG_lua_isnilstring") wchar_t *
-%{
-$1 = str2wstr(lua_tostring( L, $input ),lua_rawlen( L, $input ));
-if ($1==0) {SWIG_Lua_pushferrstring(L,"Error in converting to wchar (arg %d)",$input);goto fail;}
-%}
-
-%typemap(freearg) wchar_t *
-%{
-free($1);
-%}
-
-%typemap(typecheck) wchar_t * = char *;
diff --git a/share/swig/2.0.11/modula3/modula3.swg b/share/swig/2.0.11/modula3/modula3.swg
deleted file mode 100644
index 3affdd0..0000000
--- a/share/swig/2.0.11/modula3/modula3.swg
+++ /dev/null
@@ -1,754 +0,0 @@
-/* -----------------------------------------------------------------------------
- * modula3.swg
- *
- * Modula3 typemaps
- * ----------------------------------------------------------------------------- */
-
-%include <modula3head.swg>
-
-/* The ctype, m3rawtype and m3wraptype typemaps work together and so there should be one of each. 
- * The ctype typemap contains the C type used in the signature of C wrappers for C++ functions. 
- * The m3rawtype typemap contains the M3 type used in the raw interface.
- * The m3rawintype typemap contains the M3 type used as function argument.
- * The m3rawrettype typemap contains the M3 type used as return value.
- * The m3wraptype typemap contains the M3 type used in the M3 type wrapper classes and module class. */
-
-/* Primitive types */
-%typemap(ctype) bool,               const bool &               "bool"
-%typemap(ctype) char,               const char &               "char"
-%typemap(ctype) signed char,        const signed char &        "signed char"
-%typemap(ctype) unsigned char,      const unsigned char &      "unsigned short"
-%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) char *                                         "char *"
-%typemap(ctype) void                                           "void"
-
-%typemap(m3rawtype) bool,               const bool &               "BOOLEAN"
-%typemap(m3rawtype) char,               const char &               "C.char"
-%typemap(m3rawtype) signed char,        const signed char &        "C.signed_char"
-%typemap(m3rawtype) unsigned char,      const unsigned char &      "C.unsigned_char"
-%typemap(m3rawtype) short,              const short &              "C.short"
-%typemap(m3rawtype) unsigned short,     const unsigned short &     "C.unsigned_short"
-%typemap(m3rawtype) int,                const int &                "C.int"
-%typemap(m3rawtype) unsigned int,       const unsigned int &       "C.unsigned_int"
-%typemap(m3rawtype) long,               const long &               "C.long"
-%typemap(m3rawtype) unsigned long,      const unsigned long &      "C.unsigned_long"
-%typemap(m3rawtype) long long,          const long long &          "C.long_long"
-%typemap(m3rawtype) unsigned long long, const unsigned long long & "C.unsigned_long_long"
-%typemap(m3rawtype) float,              const float &              "C.float"
-%typemap(m3rawtype) double,             const double &             "C.double"
-%typemap(m3rawtype) long double,        const long double &        "C.long_double"
-%typemap(m3rawtype) char *                                         "C.char_star"
-%typemap(m3rawtype) void                                           ""
-%typemap(m3rawtype) FILE                                           "Cstdio.FILE";
-%typemap(m3rawtype) FILE *                                         "Cstdio.FILE_star";
-
-
-%typemap(m3rawintype) bool *,               bool &,               bool               "BOOLEAN"
-%typemap(m3rawintype) char *,               char &,               char               "C.char"
-%typemap(m3rawintype) signed char *,        signed char &,        signed char        "C.signed_char"
-%typemap(m3rawintype) unsigned char *,      unsigned char &,      unsigned char      "C.unsigned_char"
-%typemap(m3rawintype) short *,              short &,              short              "C.short"
-%typemap(m3rawintype) unsigned short *,     unsigned short &,     unsigned short     "C.unsigned_short"
-%typemap(m3rawintype) int *,                int &,                int                "C.int"
-%typemap(m3rawintype) unsigned int *,       unsigned int &,       unsigned int       "C.unsigned_int"
-%typemap(m3rawintype) long *,               long &,               long               "C.long"
-%typemap(m3rawintype) unsigned long *,      unsigned long &,      unsigned long      "C.unsigned_long"
-%typemap(m3rawintype) long long *,          long long &,          long long          "C.long_long"
-%typemap(m3rawintype) unsigned long long *, unsigned long long &, unsigned long long "C.unsigned_long_long"
-%typemap(m3rawintype) float *,              float &,              float              "C.float"
-%typemap(m3rawintype) double *,             double &,             double             "C.double"
-%typemap(m3rawintype) long double *,        long double &,        long double        "C.long_double"
-%typemap(m3rawintype) char *                                                         "C.char_star"
-%typemap(m3rawintype) void                                                           ""
-%typemap(m3rawintype) void *                                                         "ADDRESS"
-%typemap(m3rawintype) FILE                                                           "Cstdio.FILE";
-%typemap(m3rawintype) FILE *                                                         "Cstdio.FILE_star";
-
-%typemap(m3rawinmode) char *, void *, FILE *  ""
-
-
-%typemap(m3rawrettype) bool,               const bool &               "BOOLEAN"
-%typemap(m3rawrettype) char,               const char &               "C.char"
-%typemap(m3rawrettype) signed char,        const signed char &        "C.signed_char"
-%typemap(m3rawrettype) unsigned char,      const unsigned char &      "C.unsigned_char"
-%typemap(m3rawrettype) short,              const short &              "C.short"
-%typemap(m3rawrettype) unsigned short,     const unsigned short &     "C.unsigned_short"
-%typemap(m3rawrettype) int,                const int &                "C.int"
-%typemap(m3rawrettype) unsigned int,       const unsigned int &       "C.unsigned_int"
-%typemap(m3rawrettype) long,               const long &               "C.long"
-%typemap(m3rawrettype) unsigned long,      const unsigned long &      "C.unsigned_long"
-%typemap(m3rawrettype) long long,          const long long &          "C.long_long"
-%typemap(m3rawrettype) unsigned long long, const unsigned long long & "C.unsigned_long_long"
-%typemap(m3rawrettype) float,              const float &              "C.float"
-%typemap(m3rawrettype) double,             const double &             "C.double"
-%typemap(m3rawrettype) long double,        const long double &        "C.long_double"
-%typemap(m3rawrettype) char *                                         "C.char_star"
-%typemap(m3rawrettype) void                                           ""
-%typemap(m3rawrettype) void *                                         "ADDRESS"
-%typemap(m3rawrettype) FILE                                           "Cstdio.FILE";
-%typemap(m3rawrettype) FILE *                                         "Cstdio.FILE_star";
-
-
-%typemap("m3rawtype:import")
-  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 &,
-  long double,        const long double &,
-  char *
-    "Ctypes AS C"
-
-%typemap("m3rawintype:import")
-  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 &,
-  long double,        const long double &,
-  char *
-    "Ctypes AS C"
-
-%typemap("m3rawrettype:import")
-  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 &,
-  long double,        const long double &,
-  char *
-    "Ctypes AS C"
-
-%typemap("m3rawtype:import")
-  FILE,   FILE *
-    "Cstdio";
-
-%typemap("m3rawintype:import")
-  FILE,   FILE *
-    "Cstdio";
-
-%typemap("m3rawrettype:import")
-  FILE,   FILE *
-    "Cstdio";
-
-%typemap(m3wraptype) bool,               const bool &               "BOOLEAN"
-%typemap(m3wraptype) char,               const char &               "CHAR"
-%typemap(m3wraptype) signed char,        const signed char &        "CHAR"
-%typemap(m3wraptype) unsigned char,      const unsigned char &      "CHAR"
-%typemap(m3wraptype) short,              const short &              "Integer16.T"
-%typemap(m3wraptype) unsigned short,     const unsigned short &     "Cardinal16.T"
-%typemap(m3wraptype) int,                const int &                "INTEGER"
-%typemap(m3wraptype) unsigned int,       const unsigned int &       "CARDINAL"
-%typemap(m3wraptype) long,               const long &               "Integer32.T"
-%typemap(m3wraptype) unsigned long,      const unsigned long &      "Cardinal32.T"
-%typemap(m3wraptype) long long,          const long long &          "Integer64.T"
-%typemap(m3wraptype) unsigned long long, const unsigned long long & "Cardinal64.T"
-%typemap(m3wraptype) float,              const float &              "REAL"
-%typemap(m3wraptype) double,             const double &             "LONGREAL"
-%typemap(m3wraptype) long double,        const long double &        "EXTENDED"
-%typemap(m3wraptype) char *                                         "TEXT"
-%typemap(m3wraptype) void                                           ""
-%typemap(m3wraptype) FILE                                           "Cstdio.FILE";
-%typemap(m3wraptype) FILE *                                         "Cstdio.FILE_star";
-
-%typemap(m3wrapintype) bool,               const bool *,               const bool &               "BOOLEAN"
-%typemap(m3wrapintype) char,               const char *,               const char &               "CHAR"
-%typemap(m3wrapintype) signed char,        const signed char *,        const signed char &        "CHAR"
-%typemap(m3wrapintype) unsigned char,      const unsigned char *,      const unsigned char &      "CHAR"
-%typemap(m3wrapintype) short,              const short *,              const short &              "INTEGER"
-%typemap(m3wrapintype) unsigned short,     const unsigned short *,     const unsigned short &     "CARDINAL"
-%typemap(m3wrapintype) int,                const int *,                const int &                "INTEGER"
-%typemap(m3wrapintype) unsigned int,       const unsigned int *,       const unsigned int &       "CARDINAL"
-%typemap(m3wrapintype) long,               const long *,               const long &               "INTEGER"
-%typemap(m3wrapintype) unsigned long,      const unsigned long *,      const unsigned long &      "CARDINAL"
-%typemap(m3wrapintype) long long,          const long long *,          const long long &          "INTEGER"
-%typemap(m3wrapintype) unsigned long long, const unsigned long long *, const unsigned long long & "CARDINAL"
-%typemap(m3wrapintype) float,              const float *,              const float &              "REAL"
-%typemap(m3wrapintype) double,             const double *,             const double &             "LONGREAL"
-%typemap(m3wrapintype) long double,        const long double *,        const long double &        "EXTENDED"
-%typemap(m3wrapintype) const char *, const char []   "TEXT"
-%typemap(m3wrapintype,numinputs=0) void              ""
-%typemap(m3wrapintype) FILE            "Cstdio.FILE";
-%typemap(m3wrapintype) FILE *          "Cstdio.FILE_star";
-
-
-%typemap(m3wrapouttype) bool,               bool *,               bool &                  "BOOLEAN"
-%typemap(m3wrapouttype) char,               char *,               char &                  "CHAR"
-%typemap(m3wrapouttype) signed char,        signed char *,        signed char &           "CHAR"
-%typemap(m3wrapouttype) unsigned char,      unsigned char *,      unsigned char &         "CHAR"
-%typemap(m3wrapouttype) short,              short *,              short &                 "INTEGER"
-%typemap(m3wrapouttype) unsigned short,     unsigned short *,     unsigned short &        "CARDINAL"
-%typemap(m3wrapouttype) int,                int *,                int &                   "INTEGER"
-%typemap(m3wrapouttype) unsigned int,       unsigned int *,       unsigned int &          "CARDINAL"
-%typemap(m3wrapouttype) long,               long *,               long &                  "INTEGER"
-%typemap(m3wrapouttype) unsigned long,      unsigned long *,      unsigned long &         "CARDINAL"
-%typemap(m3wrapouttype) long long,          long long *,          long long &             "INTEGER"
-%typemap(m3wrapouttype) unsigned long long, unsigned long long *, unsigned long long &    "CARDINAL"
-%typemap(m3wrapouttype) float,              float *,              float &                 "REAL"
-%typemap(m3wrapouttype) double,             double *,             double &                "LONGREAL"
-%typemap(m3wrapouttype) long double,        long double *,        long double &           "EXTENDED"
-%typemap(m3wrapouttype) char *, char []    "TEXT"
-%typemap(m3wrapouttype,numinputs=0) void   ""
-
-%typemap(m3wraprettype) bool,               const bool &               "BOOLEAN"
-%typemap(m3wraprettype) char,               const char &               "CHAR"
-%typemap(m3wraprettype) signed char,        const signed char &        "CHAR"
-%typemap(m3wraprettype) unsigned char,      const unsigned char &      "CHAR"
-%typemap(m3wraprettype) short,              const short &              "INTEGER"
-%typemap(m3wraprettype) unsigned short,     const unsigned short &     "CARDINAL"
-%typemap(m3wraprettype) int,                const int &                "INTEGER"
-%typemap(m3wraprettype) unsigned int,       const unsigned int &       "CARDINAL"
-%typemap(m3wraprettype) long,               const long &               "INTEGER"
-%typemap(m3wraprettype) unsigned long,      const unsigned long &      "CARDINAL"
-%typemap(m3wraprettype) long long,          const long long &          "INTEGER"
-%typemap(m3wraprettype) unsigned long long, const unsigned long long & "CARDINAL"
-%typemap(m3wraprettype) float,              const float &              "REAL"
-%typemap(m3wraprettype) double,             const double &             "LONGREAL"
-%typemap(m3wraprettype) long double,        const long double &        "EXTENDED"
-%typemap(m3wraprettype) char *                                         "TEXT"
-%typemap(m3wraprettype) void                                           ""
-%typemap(m3wraprettype) FILE            "Cstdio.FILE";
-%typemap(m3wraprettype) FILE *          "Cstdio.FILE_star";
-
-
-%typemap(ctype)          char[ANY]               "char *"
-%typemap(m3rawtype)      char[ANY]               "C.char_star"
-%typemap(m3rawintype)    char[ANY]               "C.char_star"
-%typemap(m3rawrettype)   char[ANY]               "C.char_star"
-%typemap(m3wraptype)     char[ANY]               "TEXT"
-%typemap(m3wrapintype)   char[ANY]               "TEXT"
-%typemap(m3wrapouttype)  char[ANY]               "TEXT"
-%typemap(m3wraprettype)  char[ANY]               "TEXT"
-
-%typemap(m3wrapinmode)  const char * %{%}
-%typemap(m3wrapargvar)  const char * %{$1 : C.char_star;%}
-%typemap(m3wrapinconv)  const char * %{$1 := M3toC.SharedTtoS($1_name);%}
-%typemap(m3wrapfreearg) const char * %{M3toC.FreeSharedS($1_name,$1);%}
-%typemap(m3wrapargraw)  const char * %{$1%}
-%typemap("m3wrapargvar:import")  const char * "Ctypes AS C"
-%typemap("m3wrapinconv:import")  const char * "M3toC"
-%typemap("m3wrapfreearg:import") const char * "M3toC"
-
-%typemap(m3wrapretvar)  char * %{result : C.char_star;%}
-%typemap(m3wrapretraw)  char * %{result%}
-%typemap(m3wrapretconv) char * %{M3toC.CopyStoT(result)%}
-%typemap("m3wrapretvar:import")  char * "Ctypes AS C"
-%typemap("m3wrapretconv:import") char * "M3toC"
-
-%typemap(m3wrapinmode)  FILE * %{%}
-
-
-%typemap("m3wraptype:import")
-  FILE,   FILE *
-    "Cstdio";
-
-%typemap("m3wrapintype:import")
-  FILE,   FILE *
-    "Cstdio";
-
-%typemap("m3wraprettype:import")
-  FILE,   FILE *
-    "Cstdio";
-
-
-/* Composed types */
-%typemap(ctype)                SWIGTYPE "$1_type"
-%typemap(m3rawtype)            SWIGTYPE "$1_basetype"
-%typemap(m3rawrettype)         SWIGTYPE "UNTRACED REF $1_basetype"
-%typemap(m3wraptype)           SWIGTYPE "$1_basetype"
-%typemap(m3wrapintype)         SWIGTYPE "$1_basetype"
-%typemap(m3wrapouttype)        SWIGTYPE "$1_basetype"
-%typemap(m3wraprettype)        SWIGTYPE "$1_basetype"
-
-%typemap(ctype)                SWIGTYPE [] "$1_type"
-%typemap(m3rawtype)      const SWIGTYPE [] "UNTRACED REF ARRAY INTEGER OF $1_basetype"
-%typemap(m3rawtype)            SWIGTYPE [] "UNTRACED REF ARRAY INTEGER OF $1_basetype"
-%typemap(m3rawintype)    const SWIGTYPE [] "(*ARRAY OF*) $1_basetype"
-%typemap(m3rawinmode)    const SWIGTYPE [] "READONLY"
-%typemap(m3rawintype)          SWIGTYPE [] "(*ARRAY OF*) $1_basetype"
-%typemap(m3rawinmode)          SWIGTYPE [] "VAR"
-%typemap(m3rawrettype)   const SWIGTYPE [] "UNTRACED REF ARRAY INTEGER OF $1_basetype"
-%typemap(m3rawrettype)         SWIGTYPE [] "UNTRACED REF ARRAY INTEGER OF $1_basetype"
-%typemap(m3wraptype)           SWIGTYPE [] "$1_basetype"
-%typemap(m3wrapintype)   const SWIGTYPE [] "ARRAY OF $1_basetype"
-%typemap(m3wrapinmode)   const SWIGTYPE [] "READONLY"
-%typemap(m3wrapintype)         SWIGTYPE [] "ARRAY OF $1_basetype"
-%typemap(m3wrapinmode)         SWIGTYPE [] "VAR"
-%typemap(m3wrapouttype)        SWIGTYPE [] "ARRAY OF $1_basetype"
-%typemap(m3wraprettype)        SWIGTYPE [] "REF ARRAY OF $1_basetype"
-
-%typemap(ctype)                SWIGTYPE * "$1_type"
-%typemap(m3rawtype)      const SWIGTYPE * "UNTRACED REF $1_basetype"
-%typemap(m3rawtype)            SWIGTYPE * "UNTRACED REF $1_basetype"
-%typemap(m3rawintype)    const SWIGTYPE * "$1_basetype"
-%typemap(m3rawinmode)    const SWIGTYPE * "READONLY"
-%typemap(m3rawintype)          SWIGTYPE * "$1_basetype"
-%typemap(m3rawinmode)          SWIGTYPE * "VAR"
-%typemap(m3rawrettype)   const SWIGTYPE * "UNTRACED REF $1_basetype"
-%typemap(m3rawrettype)         SWIGTYPE * "UNTRACED REF $1_basetype"
-%typemap(m3wraptype)           SWIGTYPE * "$1_basetype"
-%typemap(m3wrapintype)   const SWIGTYPE * "$1_basetype"
-%typemap(m3wrapinmode)   const SWIGTYPE * "READONLY"
-%typemap(m3wrapintype)         SWIGTYPE * "$1_basetype"
-%typemap(m3wrapinmode)         SWIGTYPE * "VAR"
-%typemap(m3wrapouttype)        SWIGTYPE * "$1_basetype"
-%typemap(m3wraprettype)        SWIGTYPE * "UNTRACED REF $1_basetype"
-
-%typemap(ctype)                SWIGTYPE & "$1_type"
-%typemap(m3rawtype)      const SWIGTYPE & "UNTRACED REF $1_basetype"
-%typemap(m3rawtype)            SWIGTYPE & "UNTRACED REF $1_basetype"
-%typemap(m3rawintype)    const SWIGTYPE & "$1_basetype"
-%typemap(m3rawinmode)    const SWIGTYPE & "READONLY"
-%typemap(m3rawintype)          SWIGTYPE & "$1_basetype"
-%typemap(m3rawinmode)          SWIGTYPE & "VAR"
-%typemap(m3rawrettype)   const SWIGTYPE & "UNTRACED REF $1_basetype"
-%typemap(m3rawrettype)         SWIGTYPE & "UNTRACED REF $1_basetype"
-%typemap(m3wraptype)           SWIGTYPE & "$1_basetype"
-%typemap(m3wrapintype)   const SWIGTYPE & "$1_basetype"
-%typemap(m3wrapinmode)   const SWIGTYPE & "READONLY"
-%typemap(m3wrapintype)         SWIGTYPE & "$1_basetype"
-%typemap(m3wrapinmode)         SWIGTYPE & "VAR"
-%typemap(m3wrapouttype)        SWIGTYPE & "$1_basetype"
-%typemap(m3wraprettype)        SWIGTYPE & "UNTRACED REF $1_basetype"
-
-%typemap(ctype)           enum SWIGTYPE "$1_type"
-%typemap(m3rawtype)       enum SWIGTYPE "C.int"
-%typemap(m3rawintype)     enum SWIGTYPE "C.int (* $1_type *)"
-%typemap(m3rawrettype)    enum SWIGTYPE "C.int"
-%typemap(m3wraptype)      enum SWIGTYPE "$*1_type"
-%typemap(m3wrapintype)    enum SWIGTYPE "$1_type"
-%typemap(m3wrapouttype)   enum SWIGTYPE "$1_type"
-%typemap(m3wraprettype)   enum SWIGTYPE "$*1_type"
-
-/* pointer to a class member */
-%typemap(ctype)      SWIGTYPE (CLASS::*) "$1_type"
-%typemap(m3rawtype)  SWIGTYPE (CLASS::*) "REFANY"
-%typemap(m3wraptype) SWIGTYPE (CLASS::*) "$1_basetype"
-
-/* The following are the in, out, freearg, argout 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(in) char, 
-             signed char, 
-             unsigned char, 
-             short, 
-             unsigned short, 
-             int, 
-             unsigned int, 
-             long, 
-             unsigned long, 
-             long long, 
-             unsigned long long, 
-             float, 
-             double, 
-             enum SWIGTYPE
-%{ $1 = ($1_ltype)$input; %}
-
-%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 = $1; %}
-%typemap(out) long long          %{ $result = $1; %}
-%typemap(out) unsigned long long %{ $result = $1; %}
-%typemap(out) float              %{ $result = $1; %}
-%typemap(out) double             %{ $result = $1; %}
-%typemap(out) enum SWIGTYPE      %{ $result = $1; %}
-
-/* char * - treat as String */
-%typemap(in) char * {
-  $1 = $input;
-}
-//%typemap(freearg) char * { if ($1) JCALL2(ReleaseStringUTFChars, jenv, $input, $1); }
-//%typemap(out) char * { if($1) $result = JCALL1(NewStringUTF, jenv, $1); }
-
-%typemap(out) void ""
-
-/* primitive types by const reference */
-%typemap(in) const bool & (bool temp)
-%{ temp = $input ? true : false; 
-   $1 = &temp; %}
-
-%typemap(in) const char & (char temp), 
-             const signed char & (signed char temp), 
-             const unsigned char & (unsigned char temp), 
-             const short & (short temp), 
-             const unsigned short & (unsigned short temp), 
-             const int & (int temp), 
-             const unsigned int & (unsigned int temp), 
-             const long & (long temp), 
-             const unsigned long & (unsigned long temp), 
-             const long long & ($*1_ltype temp), 
-             const unsigned long long & ($*1_ltype temp), 
-             const float & (float temp), 
-             const double & (double temp)
-%{ temp = ($*1_ltype)$input; 
-$1 = &temp; %}
-
-%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 = *$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) SWIGTYPE ($&1_type argp)
-%{ argp = *($&1_ltype*)&$input; 
-   if (!argp) {
-//     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null $1_type");
-     RETURN $null;
-   }
-   $1 = *argp; %}
-%typemap(out) SWIGTYPE 
-#ifdef __cplusplus
-%{*($&1_ltype*)&$result = new $1_ltype((const $1_ltype &)$1); %}
-#else
-{
-  $&1_ltype $1ptr = ($&1_ltype) malloc(sizeof($1_ltype));
-  memmove($1ptr, &$1, sizeof($1_type));
-  *($&1_ltype*)&$result = $1ptr;
-}
-#endif
-
-/* Generic pointers and references */
-%typemap(in) SWIGTYPE *, SWIGTYPE (CLASS::*) %{ $1 = *($&1_ltype)&$input; %}
-%typemap(in) SWIGTYPE & %{ $1 = *($&1_ltype)&$input;
-  if(!$1) {
-    //SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null");
-    RETURN $null;
-  } %}
-%typemap(out) SWIGTYPE *, SWIGTYPE &, SWIGTYPE (CLASS::*) %{ *($&1_ltype)&$result = $1; %} 
-
-
-/* Default array handling */
-%typemap(in) SWIGTYPE [] %{ $1 = *($&1_ltype)&$input; %}
-%typemap(out) SWIGTYPE [] %{ *($&1_ltype)&$result = $1; %} 
-
-/* char[ANY] - treat as String */
-%typemap(in) char[ANY] { 
-    $1 = $input;
-}
-
-%typemap(argout) char[ANY] ""
-%typemap(freearg) char[ANY] ""//{ if ($1) JCALL2(ReleaseStringUTFChars, jenv, $input, $1); }
-%typemap(out) char[ANY] { if($1) $result = $1; }
-
-
-/* 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) /* Java boolean */
-    bool,
-    const bool &
-    ""
-
-%typecheck(SWIG_TYPECHECK_CHAR) /* Java char */
-    char, 
-    const char &
-    ""
-
-%typecheck(SWIG_TYPECHECK_INT8) /* Java byte */
-    signed char,
-    const signed char &
-    ""
-
-%typecheck(SWIG_TYPECHECK_INT16) /* Java short */
-    unsigned char, 
-    short, 
-    const unsigned char &, 
-    const short &
-    ""
-
-%typecheck(SWIG_TYPECHECK_INT32) /* Java int */
-    unsigned short, 
-    int, 
-    long, 
-    const unsigned short &, 
-    const int &, 
-    const long &,
-    enum SWIGTYPE
-    ""
-
-%typecheck(SWIG_TYPECHECK_INT64) /* Java long */
-    unsigned int, 
-    unsigned long, 
-    long long, 
-    const unsigned int &, 
-    const unsigned long &, 
-    const long long &
-    ""
-
-%typecheck(SWIG_TYPECHECK_INT128) /* Java BigInteger */
-    unsigned long long
-    ""
-
-%typecheck(SWIG_TYPECHECK_FLOAT) /* Java float */
-    float,
-    const float &
-    ""
-
-%typecheck(SWIG_TYPECHECK_DOUBLE) /* Java double */
-    double,
-    const double &
-    ""
-
-%typecheck(SWIG_TYPECHECK_STRING) /* Java String */
-    char *,
-    char[ANY]
-    ""
-
-%typecheck(SWIG_TYPECHECK_POINTER) /* Default */
-    SWIGTYPE, 
-    SWIGTYPE *, 
-    SWIGTYPE &, 
-    SWIGTYPE [],
-    SWIGTYPE (CLASS::*)
-    ""
-
-/* Exception handling */
-
-%typemap(throws) 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_JavaThrowException(jenv, SWIG_JavaRuntimeException, error_msg);
-  RETURN $null;
-}
-
-%typemap(throws) SWIGTYPE {
-  (void)$1;
-  SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown");
-  RETURN $null;
-}
-
-%typemap(throws) char * {
-  SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1);
-  RETURN $null;
-}
-
-
-/* Typemaps for code generation in proxy classes and C# type wrapper classes */
-
-/* The in 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(m3in)     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 &,
-                 char *,
-                 char[ANY],
-                 enum SWIGTYPE 
-    "$input"
-%typemap(m3in) SWIGTYPE "$&*1_type.getCPtr($input)"
-%typemap(m3in) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) "$1_basetype.getCPtr($input)"
-
-/* The m3out 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. */
-%typemap(m3out)   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 &,
-                  char *,
-                  char[ANY],
-                  enum SWIGTYPE
-%{$imcall%}
-
-%typemap(m3out) void %{$imcall%}
-
-%typemap(m3out) SWIGTYPE %{
-    RETURN NEW(REF $1_basetype, $imcall);
-%}
-%typemap(m3out) SWIGTYPE & %{
-    RETURN NEW($1_basetype, $imcall, $owner);
-%}
-%typemap(m3out) SWIGTYPE *, SWIGTYPE [], SWIGTYPE (CLASS::*) %{
-    cPtr := $imcall;
-    RETURN (cPtr = IntPtr.Zero) ? null : NEW($1_basetype, cPtr, $owner);
-%}
-
-/* Properties */
-%typemap(m3varin) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) %{
-PROCEDURE Set$var (value: $vartype) =
-  BEGIN
-    $imcall;
-  END Set$var;
-%}
-
-%typemap(m3varout) 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 &,
-                   char *,
-                   char[ANY],
-                   enum SWIGTYPE %{
-PROCEDURE Get$var (): $vartype =
-  BEGIN
-    RETURN $imcall;
-  END Get$var;
-%}
-
-%typemap(m3varout) void %{
-    get {
-      $imcall;
-    } %}
-%typemap(m3varout) SWIGTYPE %{
-    get {
-      RETURN new $&*1_mangle($imcall, true);
-    } %}
-%typemap(m3varout) SWIGTYPE & %{
-    get {
-      RETURN new $1_basetype($imcall, $owner);
-    } %}
-%typemap(m3varout) SWIGTYPE *, SWIGTYPE [], SWIGTYPE (CLASS::*) %{
-    get {
-      IntPtr cPtr = $imcall;
-      RETURN (cPtr == IntPtr.Zero) ? null : new $1_basetype(cPtr, $owner);
-    } %}
-
-/* Typemaps used for the generation of proxy and type wrapper class code */
-%typemap(m3base)                      SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
-%typemap(m3classmodifiers)            SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) "public"
-%typemap(m3code)                      SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
-%typemap(m3imports)                   SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) "using System;"
-%typemap(m3interfaces)                SWIGTYPE "IDisposable"
-%typemap(m3interfaces_derived)                  SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
-%typemap(m3ptrconstructormodifiers) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) "internal"
-
-%typemap(m3finalize) SWIGTYPE %{
-  ~$1_basetype() {
-    Dispose();
-  }
-%}
-
-%typemap(m3destruct, methodname="Dispose") SWIGTYPE {
-    if(swigCPtr != IntPtr.Zero && swigCMemOwn) {
-      $imcall;
-      swigCMemOwn = false;
-    }
-    swigCPtr = IntPtr.Zero;
-    GC.SuppressFinalize(this);
-  }
-
-%typemap(m3destruct_derived, methodname="Dispose") SWIGTYPE {
-    if(swigCPtr != IntPtr.Zero && swigCMemOwn) {
-      $imcall;
-      swigCMemOwn = false;
-    }
-    swigCPtr = IntPtr.Zero;
-    GC.SuppressFinalize(this);
-    base.Dispose();
-  }
-
-%typemap(m3getcptr) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) %{
-  internal static IntPtr getCPtr($1_basetype obj) {
-    RETURN (obj == null) ? IntPtr.Zero : obj.swigCPtr;
-  }
-%}
-
-/* M3 specific directives */
-#define %m3multiretval        %feature("modula3:multiretval")
-#define %constnumeric(num)    %feature("constnumeric","num")
-
-%pragma(modula3) moduleimports=%{
-IMPORT BlaBla;
-%}
-
-%pragma(modula3) imclassimports=%{
-FROM BlaBla IMPORT Bla;
-%}
-
-/* Some ANSI C typemaps */
-
-%apply unsigned long { size_t };
-
-/* Array reference typemaps */
-%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
-
-/* const pointers */
-%apply SWIGTYPE * { SWIGTYPE *const }
-
diff --git a/share/swig/2.0.11/mzscheme/std_common.i b/share/swig/2.0.11/mzscheme/std_common.i
deleted file mode 100644
index 1f1ae1a..0000000
--- a/share/swig/2.0.11/mzscheme/std_common.i
+++ /dev/null
@@ -1,20 +0,0 @@
-/* -----------------------------------------------------------------------------
- * std_common.i
- *
- * SWIG typemaps for STL - common utilities
- * ----------------------------------------------------------------------------- */
-
-%include <std/std_except.i>
-
-%apply size_t { std::size_t };
-
-%{
-#include <string>
-
-std::string swig_scm_to_string(Scheme_Object* x) {
-    return std::string(SCHEME_STR_VAL(x));
-}
-Scheme_Object* swig_make_string(const std::string& s) {
-    return scheme_make_string(s.c_str());
-}
-%}
diff --git a/share/swig/2.0.11/mzscheme/typemaps.i b/share/swig/2.0.11/mzscheme/typemaps.i
deleted file mode 100644
index 4078026..0000000
--- a/share/swig/2.0.11/mzscheme/typemaps.i
+++ /dev/null
@@ -1,358 +0,0 @@
-/* -----------------------------------------------------------------------------
- * typemaps.i
- * ----------------------------------------------------------------------------- */
-
-/* The MzScheme module handles all types uniformly via typemaps. Here
-   are the definitions.  */
-
-/* Pointers */
-
-%typemap(in) SWIGTYPE * {
-  $1 = ($ltype) SWIG_MustGetPtr($input, $descriptor, $argnum, 0);
-}
-
-%typemap(in) void * {
-  $1 = SWIG_MustGetPtr($input, NULL, $argnum, 0);
-}
-
-%typemap(varin) SWIGTYPE * {
-  $1 = ($ltype) SWIG_MustGetPtr($input, $descriptor, 1, 0);
-}
-
-%typemap(varin) SWIGTYPE & {
-  $1 = *(($1_ltype)SWIG_MustGetPtr($input, $descriptor, 1, 0));
-}
-
-%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 * {
-  $result = SWIG_NewPointerObj ($1, $descriptor, $owner);
-}
-
-%typemap(out) SWIGTYPE *DYNAMIC {
-  swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor,(void **) &$1);
-  $result = SWIG_NewPointerObj ($1, ty, $owner);
-}
-    
-%typemap(varout) SWIGTYPE *, SWIGTYPE [] {
-  $result = SWIG_NewPointerObj ($1, $descriptor, 0);
-}
-
-%typemap(varout) SWIGTYPE & {
-  $result = SWIG_NewPointerObj((void *) &$1, $1_descriptor, 0);
-}
-
-/* C++ References */
-
-#ifdef __cplusplus
-
-%typemap(in) SWIGTYPE &, const SWIGTYPE & { 
-  $1 = ($ltype) SWIG_MustGetPtr($input, $descriptor, $argnum, 0);
-  if ($1 == NULL) scheme_signal_error("swig-type-error (null reference)");
-}
-
-%typemap(out) SWIGTYPE &, const SWIGTYPE & {
-  $result = SWIG_NewPointerObj ($1, $descriptor, $owner);
-}
-
-%typemap(out) SWIGTYPE &DYNAMIC {
-  swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor,(void **) &$1);
-  $result = SWIG_NewPointerObj ($1, ty, $owner);
-}
-
-#endif
-
-/* Arrays */
-
-%typemap(in) SWIGTYPE[] {
-  $1 = ($ltype) SWIG_MustGetPtr($input, $descriptor, $argnum, 0);
-}
-
-%typemap(out) SWIGTYPE[] {
-  $result = SWIG_NewPointerObj ($1, $descriptor, $owner);
-}
-
-/* Enums */
-%typemap(in) enum SWIGTYPE {
-  if (!SWIG_is_integer($input)) 
-      scheme_wrong_type(FUNC_NAME, "integer", $argnum - 1, argc, argv);
-  $1 = ($1_type) SWIG_convert_int($input);
-}
-
-%typemap(varin) enum SWIGTYPE {
-  if (!SWIG_is_integer($input)) 
-      scheme_wrong_type(FUNC_NAME, "integer", 0, argc, argv);
-  $1 = ($1_type) SWIG_convert_int($input);
-}
-
-%typemap(out) enum SWIGTYPE "$result = scheme_make_integer_value($1);";
-%typemap(varout) enum SWIGTYPE "$result = scheme_make_integer_value($1);";
-
-
-/* Pass-by-value */
-
-%typemap(in) SWIGTYPE($&1_ltype argp) {
-  argp = ($&1_ltype) SWIG_MustGetPtr($input, $&1_descriptor, $argnum, 0);
-  $1 = *argp;
-}
-
-%typemap(varin) SWIGTYPE {
-  $&1_ltype argp;
-  argp = ($&1_ltype) SWIG_MustGetPtr($input, $&1_descriptor, 1, 0);
-  $1 = *argp;
-}
-
-
-%typemap(out) SWIGTYPE 
-#ifdef __cplusplus
-{
-  $&1_ltype resultptr;
-  resultptr = new $1_ltype(($1_ltype &) $1);
-  $result =  SWIG_NewPointerObj (resultptr, $&1_descriptor, 1);
-} 
-#else
-{
-  $&1_ltype resultptr;
-  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;
-  resultptr = new $1_ltype(($1_ltype &) $1);
-  $result =  SWIG_NewPointerObj (resultptr, $&1_descriptor, 0);
-} 
-#else
-{
-  $&1_ltype resultptr;
-  resultptr = ($&1_ltype) malloc(sizeof($1_type));
-  memmove(resultptr, &$1, sizeof($1_type));
-  $result = SWIG_NewPointerObj(resultptr, $&1_descriptor, 0);
-}
-#endif
-
-/* The SIMPLE_MAP macro below defines the whole set of typemaps needed
-   for simple types. */
-
-%define SIMPLE_MAP(C_NAME, MZ_PREDICATE, MZ_TO_C, C_TO_MZ, MZ_NAME)
-%typemap(in) C_NAME {
-    if (!MZ_PREDICATE($input))
-	scheme_wrong_type(FUNC_NAME, #MZ_NAME, $argnum - 1, argc, argv);
-    $1 = MZ_TO_C($input);
-}
-%typemap(varin) C_NAME {
-    if (!MZ_PREDICATE($input))
-	scheme_wrong_type(FUNC_NAME, #MZ_NAME, 0, argc, argv);
-    $1 = MZ_TO_C($input);
-}
-%typemap(out) C_NAME {
-    $result = C_TO_MZ($1);
-}
-%typemap(varout) C_NAME {
-    $result = C_TO_MZ($1);
-}
-%typemap(in) C_NAME *INPUT (C_NAME temp) {
-    temp = (C_NAME) MZ_TO_C($input);
-    $1 = &temp;
-}
-%typemap(in,numinputs=0) C_NAME *OUTPUT (C_NAME temp) {
-    $1 = &temp;
-}
-%typemap(argout) C_NAME *OUTPUT {
-    Scheme_Object *s;
-    s = C_TO_MZ(*$1);
-    SWIG_APPEND_VALUE(s);
-}
-%typemap(in) C_NAME *BOTH = C_NAME *INPUT;
-%typemap(argout) C_NAME *BOTH = C_NAME *OUTPUT;
-%typemap(in) C_NAME *INOUT = C_NAME *INPUT;
-%typemap(argout) C_NAME *INOUT = C_NAME *OUTPUT;
-%enddef
-
-SIMPLE_MAP(bool, SCHEME_BOOLP, SCHEME_TRUEP,
-	   swig_make_boolean, boolean);
-SIMPLE_MAP(char, SCHEME_CHARP, SCHEME_CHAR_VAL,
-	   scheme_make_character, character);
-SIMPLE_MAP(unsigned char, SCHEME_CHARP, SCHEME_CHAR_VAL,
-	   scheme_make_character, character);
-SIMPLE_MAP(int, SWIG_is_integer, SWIG_convert_int,
-	   scheme_make_integer_value, integer);
-SIMPLE_MAP(short, SWIG_is_integer, SWIG_convert_short,
-	   scheme_make_integer_value, integer);
-SIMPLE_MAP(long, SWIG_is_integer, SWIG_convert_long,
-	   scheme_make_integer_value, integer);
-SIMPLE_MAP(ptrdiff_t, SWIG_is_integer, SWIG_convert_long,
-	   scheme_make_integer_value, integer);
-SIMPLE_MAP(unsigned int, SWIG_is_unsigned_integer, SWIG_convert_unsigned_int,
-	   scheme_make_integer_value_from_unsigned, integer);
-SIMPLE_MAP(unsigned short, SWIG_is_unsigned_integer, SWIG_convert_unsigned_short,
-	   scheme_make_integer_value_from_unsigned, integer);
-SIMPLE_MAP(unsigned long, SWIG_is_unsigned_integer, SWIG_convert_unsigned_long,
-	   scheme_make_integer_value_from_unsigned, integer);
-SIMPLE_MAP(size_t, SWIG_is_unsigned_integer, SWIG_convert_unsigned_long,
-	   scheme_make_integer_value_from_unsigned, integer);
-SIMPLE_MAP(float, SCHEME_REALP, scheme_real_to_double,
-	   scheme_make_double, real);
-SIMPLE_MAP(double, SCHEME_REALP, scheme_real_to_double,
-	   scheme_make_double, real);
-
-SIMPLE_MAP(char *, SCHEME_STRINGP, SCHEME_STR_VAL, 
-	   SCHEME_MAKE_STRING, string);
-SIMPLE_MAP(const char *, SCHEME_STRINGP, SCHEME_STR_VAL, 
-	   SCHEME_MAKE_STRING, string);
-
-/* For MzScheme 30x:  Use these typemaps if you are not going to use
-   UTF8 encodings in your C code. 
- SIMPLE_MAP(char *,SCHEME_BYTE_STRINGP, SCHEME_BYTE_STR_VAL,
- 	   scheme_make_byte_string_without_copying,bytestring);
- SIMPLE_MAP(const char *,SCHEME_BYTE_STRINGP, SCHEME_BYTE_STR_VAL,
- 	   scheme_make_byte_string_without_copying,bytestring);
-*/
-
-/* Const primitive references.  Passed by value */
-
-%define REF_MAP(C_NAME, MZ_PREDICATE, MZ_TO_C, C_TO_MZ, MZ_NAME)
-  %typemap(in) const C_NAME & (C_NAME temp) {
-     if (!MZ_PREDICATE($input))
-        scheme_wrong_type(FUNC_NAME, #MZ_NAME, $argnum - 1, argc, argv);
-     temp = MZ_TO_C($input);
-     $1 = &temp;
-  }
-  %typemap(out) const C_NAME & {
-    $result = C_TO_MZ(*$1);
-  }
-%enddef
-
-REF_MAP(bool, SCHEME_BOOLP, SCHEME_TRUEP,
-	   swig_make_boolean, boolean);
-REF_MAP(char, SCHEME_CHARP, SCHEME_CHAR_VAL,
-	   scheme_make_character, character);
-REF_MAP(unsigned char, SCHEME_CHARP, SCHEME_CHAR_VAL,
-	   scheme_make_character, character);
-REF_MAP(int, SWIG_is_integer, SWIG_convert_int,
-	   scheme_make_integer_value, integer);
-REF_MAP(short, SWIG_is_integer, SWIG_convert_short,
-	   scheme_make_integer_value, integer);
-REF_MAP(long, SWIG_is_integer, SWIG_convert_long,
-	   scheme_make_integer_value, integer);
-REF_MAP(unsigned int, SWIG_is_unsigned_integer, SWIG_convert_unsigned_int,
-	   scheme_make_integer_value_from_unsigned, integer);
-REF_MAP(unsigned short, SWIG_is_unsigned_integer, SWIG_convert_unsigned_short,
-	   scheme_make_integer_value_from_unsigned, integer);
-REF_MAP(unsigned long, SWIG_is_unsigned_integer, SWIG_convert_unsigned_long,
-	   scheme_make_integer_value_from_unsigned, integer);
-REF_MAP(float, SCHEME_REALP, scheme_real_to_double,
-	   scheme_make_double, real);
-REF_MAP(double, SCHEME_REALP, scheme_real_to_double,
-	   scheme_make_double, real);
-
-/* Void */
-
-%typemap(out) void "$result = scheme_void;";
-
-/* Pass through Scheme_Object * */
-
-%typemap (in) Scheme_Object * "$1=$input;";
-%typemap (out) Scheme_Object * "$result=$1;";
-%typecheck(SWIG_TYPECHECK_POINTER) Scheme_Object * "$1=1;";
-
-
-/* ------------------------------------------------------------
- * String & length
- * ------------------------------------------------------------ */
-
-//%typemap(in) (char *STRING, int LENGTH) {
-//    int temp;
-//    $1 = ($1_ltype) SWIG_Guile_scm2newstr($input, &temp);
-//    $2 = ($2_ltype) temp;
-//}
-
-
-/* ------------------------------------------------------------
- * Typechecking rules
- * ------------------------------------------------------------ */
-
-%typecheck(SWIG_TYPECHECK_INTEGER)
-	 int, short, long,
- 	 unsigned int, unsigned short, unsigned long,
-	 signed char, unsigned char,
-	 long long, unsigned long long,
-	 const int &, const short &, const long &,
- 	 const unsigned int &, const unsigned short &, const unsigned long &,
-	 const long long &, const unsigned long long &,
-	 enum SWIGTYPE
-{
-  $1 = (SWIG_is_integer($input)) ? 1 : 0;
-}
-
-%typecheck(SWIG_TYPECHECK_BOOL) bool, bool &, const bool &
-{
-  $1 = (SCHEME_BOOLP($input)) ? 1 : 0;
-}
-
-%typecheck(SWIG_TYPECHECK_DOUBLE)
-	float, double,
-	const float &, const double &
-{
-  $1 = (SCHEME_REALP($input)) ? 1 : 0;
-}
-
-%typecheck(SWIG_TYPECHECK_STRING) char {
-  $1 = (SCHEME_STRINGP($input)) ? 1 : 0;
-}
-
-%typecheck(SWIG_TYPECHECK_STRING) char * {
-  $1 = (SCHEME_STRINGP($input)) ? 1 : 0;
-}
-
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
-  void *ptr;
-  if (SWIG_ConvertPtr($input, (void **) &ptr, $1_descriptor, 0)) {
-    $1 = 0;
-  } else {
-    $1 = 1;
-  }
-}
-
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE {
-  void *ptr;
-  if (SWIG_ConvertPtr($input, (void **) &ptr, $&1_descriptor, 0)) {
-    $1 = 0;
-  } else {
-    $1 = 1;
-  }
-}
-
-%typecheck(SWIG_TYPECHECK_VOIDPTR) void * {
-  void *ptr;
-  if (SWIG_ConvertPtr($input, (void **) &ptr, 0, 0)) {
-    $1 = 0;
-  } else {
-    $1 = 1;
-  }
-}
-
-
-/* Array reference typemaps */
-%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
-
-/* const pointers */
-%apply SWIGTYPE * { SWIGTYPE *const }
-
-
diff --git a/share/swig/2.0.11/ocaml/director.swg b/share/swig/2.0.11/ocaml/director.swg
deleted file mode 100644
index 77b2fd3..0000000
--- a/share/swig/2.0.11/ocaml/director.swg
+++ /dev/null
@@ -1,102 +0,0 @@
-/* -----------------------------------------------------------------------------
- * director.swg
- *
- * This file contains support for director classes that proxy
- * method calls from C++ to Ocaml extensions.
- *
- * ----------------------------------------------------------------------------- */
-
-#ifdef __cplusplus
-
-#include <string>
-
-# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG)
-
-namespace Swig {
-  /* base class for director exceptions */
-  class DirectorException {
-    protected:
-      std::string swig_msg;
-    public:
-      DirectorException(const char* msg="") {
-      }
-      const char *getMessage() const { 
-        return swig_msg.c_str(); 
-      }
-      virtual ~DirectorException() {}
-  };
-
-  /* type mismatch in the return value from a python method call */
-  class DirectorTypeMismatchException : public Swig::DirectorException {
-    public:
-      DirectorTypeMismatchException(const char* msg="") {
-      }
-  };
-
-  /* any python exception that occurs during a director method call */
-  class DirectorMethodException : public Swig::DirectorException {};
-
-  /* attempt to call a pure virtual method via a director method */
-  class DirectorPureVirtualException : public Swig::DirectorException {
-    public:
-      DirectorPureVirtualException(const char* msg="") {
-      }
-
-      static void raise(const char *msg) {
-        throw DirectorPureVirtualException(msg);
-      }
-  };
-
-  /* simple thread abstraction for pthreads on win32 */
-#ifdef __THREAD__
-#define __PTHREAD__
-#if defined(_WIN32) || defined(__WIN32__)
-#define pthread_mutex_lock EnterCriticalSection
-#define pthread_mutex_unlock LeaveCriticalSection
-#define pthread_mutex_t CRITICAL_SECTION
-#define MUTEX_INIT(var) CRITICAL_SECTION var
-#else
-#include <pthread.h>
-#define MUTEX_INIT(var) pthread_mutex_t var = PTHREAD_MUTEX_INITIALIZER 
-#endif
-#endif
-
-  /* director base class */
-  class Director {
-    private:
-      /* pointer to the wrapped ocaml object */
-      CAML_VALUE swig_self;
-      /* flag indicating whether the object is owned by ocaml or c++ */
-      mutable bool swig_disown_flag;
-
-    public:
-      /* wrap a ocaml object, optionally taking ownership */
-      Director(CAML_VALUE self) : swig_self(self), swig_disown_flag(false) {
-        register_global_root(&swig_self);
-      }
-
-      /* discard our reference at destruction */
-      virtual ~Director() {
-        remove_global_root(&swig_self);
-        swig_disown(); 
-        // Disown is safe here because we're just divorcing a reference that
-        // points to us.  
-      }
-
-      /* return a pointer to the wrapped ocaml object */
-      CAML_VALUE swig_get_self() const { 
-	  return swig_self;
-      }
-
-      /* acquire ownership of the wrapped ocaml object (the sense of "disown"
-       * is from ocaml) */
-      void swig_disown() const { 
-        if (!swig_disown_flag) { 
-          swig_disown_flag=true;
-          callback(*caml_named_value("caml_obj_disown"),swig_self);
-        } 
-      }
-  };
-}
-
-#endif /* __cplusplus */
diff --git a/share/swig/2.0.11/ocaml/ocamldec.swg b/share/swig/2.0.11/ocaml/ocamldec.swg
deleted file mode 100644
index e6b8939..0000000
--- a/share/swig/2.0.11/ocaml/ocamldec.swg
+++ /dev/null
@@ -1,169 +0,0 @@
-/* -----------------------------------------------------------------------------
- * ocamldec.swg
- *
- * Ocaml runtime code -- declarations
- * ----------------------------------------------------------------------------- */
-
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-
-#ifdef __cplusplus
-#define SWIGEXT extern "C"
-SWIGEXT {
-#else
-#define SWIGEXT 
-#endif
-#define value caml_value_t
-#define CAML_VALUE caml_value_t
-#include <caml/alloc.h>
-#include <caml/custom.h>
-#include <caml/mlvalues.h>
-#include <caml/memory.h>
-#include <caml/callback.h>
-#include <caml/fail.h>
-#include <caml/misc.h>
-
-#define caml_array_set swig_caml_array_set
-
-// Adapted from memory.h and mlvalues.h
-
-#define SWIG_CAMLlocal1(x) \
-  caml_value_t x = 0; \
-  CAMLxparam1 (x)
-
-#define SWIG_CAMLlocal2(x, y) \
-  caml_value_t x = 0, y = 0; \
-  CAMLxparam2 (x, y)
-
-#define SWIG_CAMLlocal3(x, y, z) \
-  caml_value_t x = 0, y = 0, z = 0; \
-  CAMLxparam3 (x, y, z)
-
-#define SWIG_CAMLlocal4(x, y, z, t) \
-  caml_value_t x = 0, y = 0, z = 0, t = 0; \
-  CAMLxparam4 (x, y, z, t)
-
-#define SWIG_CAMLlocal5(x, y, z, t, u) \
-  caml_value_t x = 0, y = 0, z = 0, t = 0, u = 0; \
-  CAMLxparam5 (x, y, z, t, u)
-
-#define SWIG_CAMLlocalN(x, size) \
-  caml_value_t x [(size)] = { 0, /* 0, 0, ... */ }; \
-  CAMLxparamN (x, (size))
-
-#define SWIG_Field(x, i) (((caml_value_t *)(x)) [i])           /* Also an l-value. */
-#define SWIG_Store_field(block, offset, val) do{ \
-  mlsize_t caml__temp_offset = (offset); \
-  caml_value_t caml__temp_val = (val); \
-  modify (&SWIG_Field ((block), caml__temp_offset), caml__temp_val); \
-}while(0)
-
-#define SWIG_Data_custom_val(v) ((void *) &SWIG_Field((v), 1))
-#ifdef ARCH_BIG_ENDIAN
-#define SWIG_Tag_val(val) (((unsigned char *) (val)) [-1])
-                                                 /* Also an l-value. */
-#define SWIG_Tag_hp(hp) (((unsigned char *) (hp)) [sizeof(caml_value_t)-1])
-                                                 /* Also an l-value. */
-#else
-#define SWIG_Tag_val(val) (((unsigned char *) (val)) [-sizeof(caml_value_t)])
-                                                 /* Also an l-value. */
-#define SWIG_Tag_hp(hp) (((unsigned char *) (hp)) [0])
-                                                 /* Also an l-value. */
-#endif
-
-#ifdef CAMLreturn0
-#undef CAMLreturn0
-#endif
-#define CAMLreturn0 do{ \
-  caml_local_roots = caml__frame; \
-  return; \
-}while (0)
-
-#ifdef CAMLreturn
-#undef CAMLreturn
-#endif
-#define CAMLreturn(result) do{ \
-  caml_value_t caml__temp_result = (result); \
-  caml_local_roots = caml__frame; \
-  return (caml__temp_result); \
-}while(0)
-
-#define CAMLreturn_type(result) do{ \
-  caml_local_roots = caml__frame; \
-  return result; \
-}while(0)
-
-#ifdef CAMLnoreturn
-#undef CAMLnoreturn
-#endif
-#define CAMLnoreturn ((void) caml__frame)
-
-
-#ifndef ARCH_ALIGN_INT64
-#define SWIG_Int64_val(v) (*((int64 *) SWIG_Data_custom_val(v)))
-#else
-CAMLextern int64 Int64_val(caml_value_t v);
-#define SWIG_Int64_val(v) Int64_val(v)
-#endif
-
-#define SWIG_NewPointerObj(p,type,flags) caml_val_ptr(p,type)
-#define SWIG_GetModule(clientdata) SWIG_Ocaml_GetModule(clientdata)
-#define SWIG_SetModule(clientdata, pointer) SWIG_Ocaml_SetModule(pointer)
-
-#define SWIG_contract_assert(expr, msg) if(!(expr)) {failwith(msg);} else
-
-    SWIGSTATIC int
-    SWIG_GetPtr(void *source, void **result, swig_type_info *type, swig_type_info *result_type);
-    
-    SWIGSTATIC void *
-    SWIG_MustGetPtr (CAML_VALUE v,  swig_type_info *type);
-    
-    SWIGSTATIC CAML_VALUE _wrap_delete_void( CAML_VALUE );
-    
-    SWIGSTATIC int enum_to_int( char *name, CAML_VALUE v );
-    SWIGSTATIC CAML_VALUE int_to_enum( char *name, int v );
-
-    SWIGSTATIC CAML_VALUE caml_list_nth( CAML_VALUE lst, int n );
-    SWIGSTATIC CAML_VALUE caml_list_append( CAML_VALUE lst, CAML_VALUE elt );
-    SWIGSTATIC int caml_list_length( CAML_VALUE lst );
-    SWIGSTATIC CAML_VALUE caml_array_new( int n );
-    SWIGSTATIC void caml_array_set( CAML_VALUE arr, int n, CAML_VALUE item );
-    SWIGSTATIC CAML_VALUE caml_array_nth( CAML_VALUE arr, int n );
-    SWIGSTATIC int caml_array_length( CAML_VALUE arr );
-
-    SWIGSTATIC CAML_VALUE caml_val_char( char c );
-    SWIGSTATIC CAML_VALUE caml_val_uchar( unsigned char c );
-
-    SWIGSTATIC CAML_VALUE caml_val_short( short s );
-    SWIGSTATIC CAML_VALUE caml_val_ushort( unsigned short s );
-    
-    SWIGSTATIC CAML_VALUE caml_val_int( int x );
-    SWIGSTATIC CAML_VALUE caml_val_uint( unsigned int x );
-
-    SWIGSTATIC CAML_VALUE caml_val_long( long x );
-    SWIGSTATIC CAML_VALUE caml_val_ulong( unsigned long x );
-
-    SWIGSTATIC CAML_VALUE caml_val_float( float f );
-    SWIGSTATIC CAML_VALUE caml_val_double( double d );
-
-    SWIGSTATIC CAML_VALUE caml_val_ptr( void *p, swig_type_info *descriptor );
-
-    SWIGSTATIC CAML_VALUE caml_val_string( const char *str );
-    SWIGSTATIC CAML_VALUE caml_val_string_len( const char *str, int len );
-
-    SWIGSTATIC long caml_long_val( CAML_VALUE v );
-    SWIGSTATIC double caml_double_val( CAML_VALUE v );
-
-    SWIGSTATIC int caml_ptr_val_internal( CAML_VALUE v, void **out,
-				      swig_type_info *descriptor );
-    SWIGSTATIC void *caml_ptr_val( CAML_VALUE v, swig_type_info *descriptor );
-
-    SWIGSTATIC char *caml_string_val( CAML_VALUE v );
-    SWIGSTATIC int caml_string_len( CAML_VALUE v );
-
-#ifdef __cplusplus
-}
-#endif
-
-/* mzschemedec.swg ends here */
diff --git a/share/swig/2.0.11/ocaml/std_common.i b/share/swig/2.0.11/ocaml/std_common.i
deleted file mode 100644
index 1c39705..0000000
--- a/share/swig/2.0.11/ocaml/std_common.i
+++ /dev/null
@@ -1,19 +0,0 @@
-/* -----------------------------------------------------------------------------
- * std_common.i
- *
- * SWIG typemaps for STL - common utilities
- * ----------------------------------------------------------------------------- */
-
-%include <std/std_except.i>
-
-%apply size_t { std::size_t };
-
-%{
-#include <string>
-    CAML_VALUE SwigString_FromString(const std::string& s) {
-	return caml_val_string((char *)s.c_str());
-    }
-    std::string SwigString_AsString(CAML_VALUE o) {
-	return std::string((char *)caml_ptr_val(o,0));
-    }
-%}
diff --git a/share/swig/2.0.11/ocaml/typecheck.i b/share/swig/2.0.11/ocaml/typecheck.i
deleted file mode 100644
index 4c35006..0000000
--- a/share/swig/2.0.11/ocaml/typecheck.i
+++ /dev/null
@@ -1,176 +0,0 @@
-/* -----------------------------------------------------------------------------
- * typecheck.i
- *
- * Typechecking rules
- * ----------------------------------------------------------------------------- */
-
-%typecheck(SWIG_TYPECHECK_INTEGER) char, signed char, const char &, const signed char & {
-  if( !Is_block($input) ) $1 = 0;
-  else {
-      switch( SWIG_Tag_val($input) ) {
-      case C_char: $1 = 1; break;
-      default: $1 = 0; break;
-      }
-  }
-}
-
-%typecheck(SWIG_TYPECHECK_INTEGER) unsigned char, const unsigned char & {
-  if( !Is_block($input) ) $1 = 0;
-  else {
-      switch( SWIG_Tag_val($input) ) {
-      case C_uchar: $1 = 1; break;
-      default: $1 = 0; break;
-      }
-  }
-}
-
-%typecheck(SWIG_TYPECHECK_INTEGER) short, signed short, const short &, const signed short &, wchar_t {
-  if( !Is_block($input) ) $1 = 0;
-  else {
-      switch( SWIG_Tag_val($input) ) {
-      case C_short: $1 = 1; break;
-      default: $1 = 0; break;
-      }
-  }
-}
-
-%typecheck(SWIG_TYPECHECK_INTEGER) unsigned short, const unsigned short & {
-  if( !Is_block($input) ) $1 = 0;
-  else {
-      switch( SWIG_Tag_val($input) ) {
-      case C_ushort: $1 = 1; break;
-      default: $1 = 0; break;
-      }
-  }
-}
-
-// XXX arty 
-// Will move enum SWIGTYPE later when I figure out what to do with it...
-
-%typecheck(SWIG_TYPECHECK_INTEGER) int, signed int, const int &, const signed int &, enum SWIGTYPE {
-  if( !Is_block($input) ) $1 = 0;
-  else {
-      switch( SWIG_Tag_val($input) ) {
-      case C_int: $1 = 1; break;
-      default: $1 = 0; break;
-      }
-  }
-}
-
-%typecheck(SWIG_TYPECHECK_INTEGER) unsigned int, const unsigned int & {
-  if( !Is_block($input) ) $1 = 0;
-  else {
-      switch( SWIG_Tag_val($input) ) {
-      case C_uint: $1 = 1; break;
-      case C_int32: $1 = 1; break;
-      default: $1 = 0; break;
-      }
-  }
-}
-
-%typecheck(SWIG_TYPECHECK_INTEGER) long, signed long, unsigned long, long long, signed long long, unsigned long long, const long &, const signed long &, const unsigned long &, const long long &, const signed long long &, const unsigned long long & {
-  if( !Is_block($input) ) $1 = 0;
-  else {
-      switch( SWIG_Tag_val($input) ) {
-      case C_int64: $1 = 1; break;
-      default: $1 = 0; break;
-      }
-  }
-}
-
-%typecheck(SWIG_TYPECHECK_INTEGER) bool, oc_bool, BOOL, const bool &, const oc_bool &, const BOOL & {
-  if( !Is_block($input) ) $1 = 0;
-  else {
-      switch( SWIG_Tag_val($input) ) {
-      case C_bool: $1 = 1; break;
-      default: $1 = 0; break;
-      }
-  }
-}
-
-%typecheck(SWIG_TYPECHECK_DOUBLE) float, const float & {
-  if( !Is_block($input) ) $1 = 0;
-  else {
-      switch( SWIG_Tag_val($input) ) {
-      case C_float: $1 = 1; break;
-      default: $1 = 0; break;
-      }
-  }  
-}
-
-%typecheck(SWIG_TYPECHECK_DOUBLE) double, const double & {
-  if( !Is_block($input) ) $1 = 0;
-  else {
-      switch( SWIG_Tag_val($input) ) {
-      case C_double: $1 = 1; break;
-      default: $1 = 0; break;
-      }
-  }  
-}
-
-%typecheck(SWIG_TYPECHECK_STRING) char * {
-  if( !Is_block($input) ) $1 = 0;
-  else {
-      switch( SWIG_Tag_val($input) ) {
-      case C_string: $1 = 1; break;
-      case C_ptr: {
-	swig_type_info *typeinfo = 
-	    (swig_type_info *)(long)SWIG_Int64_val(SWIG_Field($input,1));
-	$1 = SWIG_TypeCheck("char *",typeinfo) ||
-	     SWIG_TypeCheck("signed char *",typeinfo) ||
-	     SWIG_TypeCheck("unsigned char *",typeinfo) ||
-	     SWIG_TypeCheck("const char *",typeinfo) ||
-	     SWIG_TypeCheck("const signed char *",typeinfo) ||
-	     SWIG_TypeCheck("const unsigned char *",typeinfo) ||
-	     SWIG_TypeCheck("std::string",typeinfo);
-      } break;
-      default: $1 = 0; break;
-      }
-  }    
-}
-
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
-  void *ptr;
-  $1 = !caml_ptr_val_internal($input, &ptr,$descriptor);
-}
-
-#if 0
-
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE {
-  void *ptr;
-  $1 = !caml_ptr_val_internal($input, &ptr, $&1_descriptor);
-}
-
-#endif
-
-%typecheck(SWIG_TYPECHECK_VOIDPTR) void * {
-  void *ptr;
-  $1 = !caml_ptr_val_internal($input, &ptr, 0);
-}
-
-/* ------------------------------------------------------------
- * Exception handling
- * ------------------------------------------------------------ */
-
-%typemap(throws) int, 
-                  long, 
-                  short, 
-                  unsigned int, 
-                  unsigned long, 
-                  unsigned short {
-  SWIG_exception($1,"Thrown exception from C++ (int)");
-}
-
-%typemap(throws) SWIGTYPE CLASS {
-  $&1_ltype temp = new $1_ltype($1);
-  SWIG_exception((int)temp,"Thrown exception from C++ (object)");
-}
-
-%typemap(throws) SWIGTYPE {
-  (void)$1;
-  SWIG_exception(0,"Thrown exception from C++ (unknown)");
-}
-
-%typemap(throws) char * {
-  SWIG_exception(0,$1);
-}
diff --git a/share/swig/2.0.11/ocaml/typemaps.i b/share/swig/2.0.11/ocaml/typemaps.i
deleted file mode 100644
index a15dc16..0000000
--- a/share/swig/2.0.11/ocaml/typemaps.i
+++ /dev/null
@@ -1,335 +0,0 @@
-/* -----------------------------------------------------------------------------
- * typemaps.i
- *
- * The Ocaml module handles all types uniformly via typemaps. Here
- * are the definitions.
- * ----------------------------------------------------------------------------- */
-
-/* Pointers */
-
-%typemap(in) void ""
-
-%typemap(out) void "$result = Val_int(0);"
-
-%typemap(in) void * {
-    $1 = caml_ptr_val($input,$descriptor);
-}
-
-%typemap(varin) void * {
-    $1 = ($ltype)caml_ptr_val($input,$descriptor);
-}
-
-%typemap(out) void * {
-    $result = caml_val_ptr($1,$descriptor);
-}
-
-%typemap(varout) void * {
-    $result = caml_val_ptr($1,$descriptor);
-}
-
-#ifdef __cplusplus
-
-%typemap(in) SWIGTYPE & {
-    /* %typemap(in) SWIGTYPE & */
-    $1 = ($ltype) caml_ptr_val($input,$1_descriptor);
-}
-
-%typemap(varin) SWIGTYPE & {
-    /* %typemap(varin) SWIGTYPE & */
-    $1 = *(($ltype) caml_ptr_val($input,$1_descriptor));
-}
-
-%typemap(out) SWIGTYPE & {
-    /* %typemap(out) SWIGTYPE & */
-    CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr");
-    if( fromval ) {
-	$result = callback(*fromval,caml_val_ptr((void *) &$1,$1_descriptor));
-    } else {
-	$result = caml_val_ptr ((void *) &$1,$1_descriptor);
-    }
-}
-
-#if 0
-%typemap(argout) SWIGTYPE & {
-    CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr");
-    if( fromval ) {
-	swig_result =
-	    caml_list_append(swig_result,
-			     callback(*fromval,caml_val_ptr((void *) $1,
-							    $1_descriptor)));
-    } else {
-	swig_result =
-	    caml_list_append(swig_result,
-			     caml_val_ptr ((void *) $1,$1_descriptor));
-    }
-}
-#endif
-
-%typemap(argout) const SWIGTYPE & { }
-
-%typemap(in) SWIGTYPE {
-    $1 = *(($&1_ltype) caml_ptr_val($input,$&1_descriptor)) ;
-}
-
-%typemap(out) SWIGTYPE {
-    /* %typemap(out) SWIGTYPE */
-    $&1_ltype temp = new $ltype((const $1_ltype &) $1);
-    CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr");
-    if( fromval ) {
-	$result = callback(*fromval,caml_val_ptr((void *)temp,$&1_descriptor));
-    } else {
-	$result = caml_val_ptr ((void *)temp,$&1_descriptor);
-    }
-}
-
-%typemap(in) char *& (char *temp) {
-  /* %typemap(in) char *& */
-  temp = (char*)caml_val_ptr($1,$descriptor);
-  $1 = &temp;
-}
-
-%typemap(argout) char *& {
-  /* %typemap(argout) char *& */
-  swig_result =	caml_list_append(swig_result,caml_val_string_len(*$1, strlen(*$1)));
-}
-
-#else
-
-%typemap(in) SWIGTYPE {
-    $1 = *(($&1_ltype) caml_ptr_val($input,$&1_descriptor)) ;
-}
-
-%typemap(out) SWIGTYPE {
-    /* %typemap(out) SWIGTYPE */
-    void *temp = calloc(1,sizeof($ltype));
-    CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr");
-    memmove( temp, &$1, sizeof( $1_type ) );
-    if( fromval ) {
-	$result = callback(*fromval,caml_val_ptr((void *)temp,$&1_descriptor));
-    } else {
-	$result = caml_val_ptr ((void *)temp,$&1_descriptor);
-    }
-}
-
-%apply SWIGTYPE { const SWIGTYPE & };
-
-#endif
-
-/* The SIMPLE_MAP macro below defines the whole set of typemaps needed
-   for simple types. */
-
-%define SIMPLE_MAP(C_NAME, C_TO_MZ, MZ_TO_C)
-/* In */
-%typemap(in) C_NAME {
-    $1 = MZ_TO_C($input);
-}
-%typemap(varin) C_NAME {
-    $1 = MZ_TO_C($input);
-}
-%typemap(in) C_NAME & ($*1_ltype temp) {
-    temp = ($*1_ltype) MZ_TO_C($input);
-    $1 = &temp;
-}
-%typemap(varin) C_NAME & {
-    $1 = MZ_TO_C($input);
-}
-%typemap(directorout) C_NAME {
-    $1 = MZ_TO_C($input);
-}
-%typemap(in) C_NAME *INPUT ($*1_ltype temp) {
-    temp = ($*1_ltype) MZ_TO_C($input);
-    $1 = &temp;
-}
-%typemap(in,numinputs=0) C_NAME *OUTPUT ($*1_ltype temp) {
-    $1 = &temp;
-}
-/* Out */
-%typemap(out) C_NAME {
-    $result = C_TO_MZ($1);
-}
-%typemap(varout) C_NAME {
-    $result = C_TO_MZ($1);
-}
-%typemap(varout) C_NAME & {
-    /* %typemap(varout) C_NAME & (generic) */
-    $result = C_TO_MZ($1);
-}
-%typemap(argout) C_NAME *OUTPUT {
-    swig_result = caml_list_append(swig_result,C_TO_MZ((long)*$1));
-}
-%typemap(out) C_NAME & {
-    /* %typemap(out) C_NAME & (generic) */
-    $result = C_TO_MZ(*$1);
-}
-%typemap(argout) C_NAME & {
-    swig_result = caml_list_append(swig_result,C_TO_MZ((long)*$1));
-}
-%typemap(directorin) C_NAME {
-    args = caml_list_append(args,C_TO_MZ($1));
-}
-%enddef
-
-SIMPLE_MAP(bool, caml_val_bool, caml_long_val);
-SIMPLE_MAP(oc_bool, caml_val_bool, caml_long_val);
-SIMPLE_MAP(char, caml_val_char, caml_long_val);
-SIMPLE_MAP(signed char, caml_val_char, caml_long_val);
-SIMPLE_MAP(unsigned char, caml_val_uchar, caml_long_val);
-SIMPLE_MAP(int, caml_val_int, caml_long_val);
-SIMPLE_MAP(short, caml_val_short, caml_long_val);
-SIMPLE_MAP(wchar_t, caml_val_short, caml_long_val);
-SIMPLE_MAP(long, caml_val_long, caml_long_val);
-SIMPLE_MAP(ptrdiff_t, caml_val_int, caml_long_val);
-SIMPLE_MAP(unsigned int, caml_val_uint, caml_long_val);
-SIMPLE_MAP(unsigned short, caml_val_ushort, caml_long_val);
-SIMPLE_MAP(unsigned long, caml_val_ulong, caml_long_val);
-SIMPLE_MAP(size_t, caml_val_int, caml_long_val);
-SIMPLE_MAP(float, caml_val_float, caml_double_val);
-SIMPLE_MAP(double, caml_val_double, caml_double_val);
-SIMPLE_MAP(long long,caml_val_ulong,caml_long_val);
-SIMPLE_MAP(unsigned long long,caml_val_ulong,caml_long_val);
-
-/* Void */
-
-%typemap(out) void "$result = Val_unit;";
-
-/* Pass through value */
-
-%typemap (in) value,caml::value,CAML_VALUE "$1=$input;";
-%typemap (out) value,caml::value,CAML_VALUE "$result=$1;";
-
-/* Arrays */
-
-%typemap(in) ArrayCarrier * {
-    $1 = ($ltype)caml_ptr_val($input,$1_descriptor);
-}
-
-%typemap(out) ArrayCarrier * {
-    CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr");
-    if( fromval ) {
-	$result = callback(*fromval,caml_val_ptr((void *)$1,$1_descriptor));
-    } else {
-	$result = caml_val_ptr ((void *)$1,$1_descriptor);
-    }
-}
-
-#if 0
-%include <carray.i>
-#endif
-
-/* Handle char arrays as strings */
-
-%define %char_ptr_in(how)
-%typemap(how)  char *, signed char *, unsigned char * {
-    /* %typemap(how) char * ... */
-    $1 = ($ltype)caml_string_val($input);
-}
-/* Again work around the empty array bound bug */
-%typemap(how) char [ANY], signed char [ANY], unsigned char [ANY] {
-    /* %typemap(how) char [ANY] ... */
-    char *temp = caml_string_val($input);
-    strcpy((char *)$1,temp); 
-    /* strncpy would be better but we might not have an array size */
-}
-%enddef
-
-%char_ptr_in(in);
-%char_ptr_in(varin);
-%char_ptr_in(directorout);
-
-%define %char_ptr_out(how) 
-%typemap(how) 
-    char *, signed char *, unsigned char *, 
-    const char *, const signed char *, const unsigned char * {
-    $result = caml_val_string((char *)$1);
-}
-/* I'd like to use the length here but can't because it might be empty */
-%typemap(how)
-    char [ANY], signed char [ANY], unsigned char [ANY],
-    const char [ANY], const signed char [ANY], const unsigned char [ANY] {
-    $result = caml_val_string((char *)$1);
-}
-%enddef
-
-%char_ptr_out(out);
-%char_ptr_out(varout);
-%char_ptr_out(directorin);
-
-%define %swigtype_ptr_in(how)
-%typemap(how) SWIGTYPE * {
-    /* %typemap(how) SWIGTYPE * */
-    $1 = ($ltype)caml_ptr_val($input,$1_descriptor);
-}
-%typemap(how) SWIGTYPE (CLASS::*) {
-    /* %typemap(how) SWIGTYPE (CLASS::*) */
-    void *v = caml_ptr_val($input,$1_descriptor);
-    memcpy(& $1, &v, sizeof(v));
-}
-%enddef
-
-%define %swigtype_ptr_out(how)
-%typemap(out) SWIGTYPE * {
-    /* %typemap(how) SWIGTYPE *, SWIGTYPE (CLASS::*) */
-    CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr");
-    if( fromval ) {
-	$result = callback(*fromval,caml_val_ptr((void *)$1,$1_descriptor));
-    } else {
-	$result = caml_val_ptr ((void *)$1,$1_descriptor);
-    }
-}
-%typemap(how) SWIGTYPE (CLASS::*) {
-    /* %typemap(how) SWIGTYPE *, SWIGTYPE (CLASS::*) */
-    void *v;
-    memcpy(&v,& $1, sizeof(void *));
-    $result = caml_val_ptr (v,$1_descriptor);
-}
-%enddef
-
-%swigtype_ptr_in(in);
-%swigtype_ptr_in(varin);
-%swigtype_ptr_in(directorout);
-%swigtype_ptr_out(out);
-%swigtype_ptr_out(varout);
-%swigtype_ptr_out(directorin);
-
-%define %swigtype_array_fail(how,msg)
-%typemap(how) SWIGTYPE [] {
-    failwith(msg);
-}
-%enddef
-
-%swigtype_array_fail(in,"Array arguments for arbitrary types need a typemap");
-%swigtype_array_fail(varin,"Assignment to global arrays for arbitrary types need a typemap");
-%swigtype_array_fail(out,"Array arguments for arbitrary types need a typemap");
-%swigtype_array_fail(varout,"Array variables need a typemap");
-%swigtype_array_fail(directorin,"Array results with arbitrary types need a typemap");
-%swigtype_array_fail(directorout,"Array arguments with arbitrary types need a typemap");
-
-/* C++ References */
-
-/* Enums */
-%define %swig_enum_in(how)
-%typemap(how) enum SWIGTYPE {
-    $1 = ($type)caml_long_val_full($input,"$type_marker");
-}
-%enddef
-
-%define %swig_enum_out(how)
-%typemap(how) enum SWIGTYPE {
-    $result = callback2(*caml_named_value(SWIG_MODULE "_int_to_enum"),*caml_named_value("$type_marker"),Val_int((int)$1));
-}
-%enddef
-
-%swig_enum_in(in)
-%swig_enum_in(varin)
-%swig_enum_in(directorout)
-%swig_enum_out(out)
-%swig_enum_out(varout)
-%swig_enum_out(directorin)
-
-
-/* Array reference typemaps */
-%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
-
-/* const pointers */
-%apply SWIGTYPE * { SWIGTYPE *const }
-
diff --git a/share/swig/2.0.11/octave/boost_shared_ptr.i b/share/swig/2.0.11/octave/boost_shared_ptr.i
deleted file mode 100644
index 93b1a89..0000000
--- a/share/swig/2.0.11/octave/boost_shared_ptr.i
+++ /dev/null
@@ -1,307 +0,0 @@
-%include <shared_ptr.i>
-
-// Language specific macro implementing all the customisations for handling the smart pointer
-%define SWIG_SHARED_PTR_TYPEMAPS(CONST, TYPE...)
-
-// %naturalvar is as documented for member variables
-%naturalvar TYPE;
-%naturalvar SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
-
-// destructor wrapper customisation
-%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) CONST TYPE (void *argp, int res = 0) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (!argp) {
-    %argument_nullref("$type", $symname, $argnum);
-  } else {
-    $1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
-    if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-  }
-}
-%typemap(out) CONST TYPE {
-  %set_output(SWIG_NewPointerObj(new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1)), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-%typemap(varin) CONST TYPE {
-  void *argp = 0;
-  int newmem = 0;
-  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res, "$type", "$name");
-  }
-  if (!argp) {
-    %argument_nullref("$type", $symname, $argnum);
-  } else {
-    $1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
-    if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-  }
-}
-%typemap(varout) CONST TYPE {
-  %set_varoutput(SWIG_NewPointerObj(new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1)), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-// plain pointer
-// Note: $disown not implemented as it will lead to a memory leak of the shared_ptr instance
-%typemap(in) CONST TYPE * (void  *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (newmem & SWIG_CAST_NEW_MEMORY) {
-    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    $1 = %const_cast(tempshared.get(), $1_ltype);
-  } else {
-    smartarg = %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
-  }
-}
-%typemap(out, fragment="SWIG_null_deleter") CONST TYPE * {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner) : 0;
-  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), $owner | SWIG_POINTER_OWN));
-}
-
-%typemap(varin) CONST TYPE * {
-  void *argp = 0;
-  int newmem = 0;
-  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res, "$type", "$name");
-  }
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0;
-  if (newmem & SWIG_CAST_NEW_MEMORY) {
-    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    $1 = %const_cast(tempshared.get(), $1_ltype);
-  } else {
-    smartarg = %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
-  }
-}
-%typemap(varout, fragment="SWIG_null_deleter") CONST TYPE * {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_0) : 0;
-  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-// plain reference
-%typemap(in) CONST TYPE & (void  *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (!argp) { %argument_nullref("$type", $symname, $argnum); }
-  if (newmem & SWIG_CAST_NEW_MEMORY) {
-    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    $1 = %const_cast(tempshared.get(), $1_ltype);
-  } else {
-    $1 = %const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
-  }
-}
-%typemap(out, fragment="SWIG_null_deleter") CONST TYPE & {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner);
-  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-%typemap(varin) CONST TYPE & {
-  void *argp = 0;
-  int newmem = 0;
-  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res, "$type", "$name");
-  }
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
-  if (!argp) { %argument_nullref("$type", $symname, $argnum); }
-  if (newmem & SWIG_CAST_NEW_MEMORY) {
-    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    $1 = *%const_cast(tempshared.get(), $1_ltype);
-  } else {
-    $1 = *%const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
-  }
-}
-%typemap(varout, fragment="SWIG_null_deleter") CONST TYPE & {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(&$1 SWIG_NO_NULL_DELETER_0);
-  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-// plain pointer by reference
-// Note: $disown not implemented as it will lead to a memory leak of the shared_ptr instance
-%typemap(in) TYPE *CONST& (void  *argp = 0, int res = 0, $*1_ltype temp = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (newmem & SWIG_CAST_NEW_MEMORY) {
-    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    temp = %const_cast(tempshared.get(), $*1_ltype);
-  } else {
-    temp = %const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $*1_ltype);
-  }
-  $1 = &temp;
-}
-%typemap(out, fragment="SWIG_null_deleter") TYPE *CONST& {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1 SWIG_NO_NULL_DELETER_$owner);
-  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-%typemap(varin) TYPE *CONST& %{
-#error "varin typemap not implemented"
-%}
-%typemap(varout) TYPE *CONST& %{
-#error "varout typemap not implemented"
-%}
-
-// shared_ptr by value
-%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > (void *argp, int res = 0) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (argp) $1 = *(%reinterpret_cast(argp, $&ltype));
-  if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $&ltype);
-}
-%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
-  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
-  int newmem = 0;
-  void *argp = 0;
-  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res, "$type", "$name");
-  }
-  $1 = argp ? *(%reinterpret_cast(argp, $&ltype)) : SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE >();
-  if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $&ltype);
-}
-%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
-  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-// shared_ptr by reference
-%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & (void *argp, int res = 0, $*1_ltype tempshared) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (newmem & SWIG_CAST_NEW_MEMORY) {
-    if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
-    delete %reinterpret_cast(argp, $ltype);
-    $1 = &tempshared;
-  } else {
-    $1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
-  }
-}
-%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
-  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
-#error "varin typemap not implemented"
-%}
-%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
-#error "varout typemap not implemented"
-%}
-
-// shared_ptr by pointer
-%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * (void *argp, int res = 0, $*1_ltype tempshared) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (newmem & SWIG_CAST_NEW_MEMORY) {
-    if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
-    delete %reinterpret_cast(argp, $ltype);
-    $1 = &tempshared;
-  } else {
-    $1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
-  }
-}
-%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 && *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
-  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-  if ($owner) delete $1;
-}
-
-%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
-#error "varin typemap not implemented"
-%}
-%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
-#error "varout typemap not implemented"
-%}
-
-// shared_ptr by pointer reference
-%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& (void *argp, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, $*1_ltype temp = 0) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (argp) tempshared = *%reinterpret_cast(argp, $*ltype);
-  if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $*ltype);
-  temp = &tempshared;
-  $1 = &temp;
-}
-%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 && **$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(**$1) : 0;
-  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
-#error "varin typemap not implemented"
-%}
-%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
-#error "varout typemap not implemented"
-%}
-
-// Typecheck typemaps
-// Note: SWIG_ConvertPtr with void ** parameter set to 0 instead of using SWIG_ConvertPtrAndOwn, so that the casting 
-// function is not called thereby avoiding a possible smart pointer copy constructor call when casting up the inheritance chain.
-%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1) 
-                      TYPE CONST,
-                      TYPE CONST &,
-                      TYPE CONST *,
-                      TYPE *CONST&,
-                      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 > *& {
-  int res = SWIG_ConvertPtr($input, 0, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), 0);
-  $1 = SWIG_CheckState(res);
-}
-
-
-// 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"
-%}
-
-
-%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
-%enddef
-
diff --git a/share/swig/2.0.11/octave/director.swg b/share/swig/2.0.11/octave/director.swg
deleted file mode 100644
index 5e5d6f1..0000000
--- a/share/swig/2.0.11/octave/director.swg
+++ /dev/null
@@ -1,124 +0,0 @@
-
-# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG)
-
-namespace Swig {
-
-  class Director {
-    octave_swig_type *self;
-    bool swig_disowned;
-
-    Director(const Director &x);
-    Director &operator=(const Director &rhs);
-  public:
-
-    Director(void *vptr):self(0), swig_disowned(false) {
-      set_rtdir(vptr, this);
-    }
-
-    ~Director() {
-      swig_director_destroyed(self, this);
-      if (swig_disowned)
-	self->decref();
-    }
-
-    void swig_set_self(octave_swig_type *new_self) {
-      assert(!swig_disowned);
-      self = new_self;
-    }
-
-    octave_swig_type *swig_get_self() const {
-      return self;
-    }
-
-    void swig_disown() {
-      if (swig_disowned)
-	return;
-      swig_disowned = true;
-      self->incref();
-    }
-  };
-
-  struct DirectorTypeMismatchException {
-    static void raise(const char *msg) {
-      // ... todo
-      throw(DirectorTypeMismatchException());
-    }
-
-    static void raise(const octave_value &ov, const char *msg) {
-      // ... todo
-      raise(msg);
-    }
-  };
-
-  struct DirectorPureVirtualException {
-    static void raise(const char *msg) {
-      // ... todo
-      throw(DirectorPureVirtualException());
-    }
-
-    static void raise(const octave_value &ov, const char *msg) {
-      // ... todo
-      raise(msg);
-    }
-  };
-
-  SWIGINTERN rtdir_map* get_rtdir_map() {
-    static swig_module_info *module = 0;
-    if (!module)
-      module = SWIG_GetModule(0);
-    if (!module)
-      return 0;
-    if (!module->clientdata)
-      module->clientdata = new rtdir_map;
-    return (rtdir_map *) module->clientdata;
-  }
-
-  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *d) {
-    rtdir_map* rm = get_rtdir_map();
-    if (rm)
-      (*rm)[vptr] = d;
-  }
-
-  SWIGINTERNINLINE void erase_rtdir(void *vptr) {
-    rtdir_map* rm = get_rtdir_map();
-    if (rm)
-      (*rm).erase(vptr);
-  }
-
-  SWIGINTERNINLINE Director *get_rtdir(void *vptr) {
-    rtdir_map* rm = get_rtdir_map();
-    if (!rm)
-      return 0;
-    rtdir_map::const_iterator pos = rm->find(vptr);
-    Director *rtdir = (pos != rm->end())? pos->second : 0;
-    return rtdir;
-  }
-
-  SWIGRUNTIME void swig_director_destroyed(octave_swig_type *self, Director *d) {
-    self->director_destroyed(d);
-  }
-
-  SWIGRUNTIME octave_swig_type *swig_director_get_self(Director *d) {
-    return d->swig_get_self();
-  }
-
-  SWIGRUNTIME void swig_director_set_self(Director *d, octave_swig_type *self) {
-    d->swig_set_self(self);
-  }
-
-}
-
-SWIGRUNTIME void swig_acquire_ownership(void *vptr) {
-  //  assert(0);
-  // ... todo
-}
-
-SWIGRUNTIME void swig_acquire_ownership_array(void *vptr) {
-  //  assert(0);
-  // ... todo
-}
-
-SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own) {
-  //  assert(0);
-  // ... todo
-}
diff --git a/share/swig/2.0.11/octave/octcontainer.swg b/share/swig/2.0.11/octave/octcontainer.swg
deleted file mode 100644
index b14b8c1..0000000
--- a/share/swig/2.0.11/octave/octcontainer.swg
+++ /dev/null
@@ -1,624 +0,0 @@
-/* -----------------------------------------------------------------------------
- * octcontainer.swg
- *
- * Octave cell <-> C++ container wrapper
- *
- * This wrapper, and its iterator, allows a general use (and reuse) of
- * the mapping between C++ and Octave, thanks to the C++ templates.
- *
- * Of course, it needs the C++ compiler to support templates, but
- * since we will use this wrapper with the STL containers, that should
- * be the case.
- * ----------------------------------------------------------------------------- */
-
-%{
-#include <iostream>
-%}
-
-
-#if !defined(SWIG_NO_EXPORT_ITERATOR_METHODS)
-# if !defined(SWIG_EXPORT_ITERATOR_METHODS)
-#  define SWIG_EXPORT_ITERATOR_METHODS SWIG_EXPORT_ITERATOR_METHODS
-# endif
-#endif
-
-%include <octiterators.swg>
-
-// The Octave C++ Wrap
-
-%insert(header) %{
-#include <stdexcept>
-%}
-
-%include <std_except.i>
-
-%fragment(SWIG_Traits_frag(octave_value),"header",fragment="StdTraits") {
-namespace swig {
-  template <>  struct traits<octave_value > {
-    typedef value_category category;
-    static const char* type_name() { return  "octave_value"; }
-  };
-  
-  template <>  struct traits_from<octave_value> {
-    typedef octave_value value_type;
-    static octave_value from(const value_type& val) {
-      return val;
-    }
-  };
-  
-  template <> 
-  struct traits_check<octave_value, value_category> {
-    static bool check(const octave_value&) {
-      return true;
-    }
-  };
-  
-  template <>  struct traits_asval<octave_value > {   
-    typedef octave_value value_type;
-    static int asval(const octave_value& obj, value_type *val) {
-      if (val) *val = obj;
-      return SWIG_OK;
-    }
-  };
-}
-}
-
-%fragment("OctSequence_Base","header",fragment="<stddef.h>")
-{
-%#include <functional>
-
-namespace std {
-  template <>
-  struct less <octave_value>: public binary_function<octave_value, octave_value, bool>
-  {
-    bool
-    operator()(const octave_value& v, const octave_value& w) const
-    { 
-      octave_value res = do_binary_op(octave_value::op_le,v,w);
-      return res.is_true();
-    }
-  };
-}
-
-namespace swig {
-  inline size_t
-  check_index(ptrdiff_t i, size_t size, bool insert = false) {
-    if ( i < 0 ) {
-      if ((size_t) (-i) <= size)
-	return (size_t) (i + size);
-    } else if ( (size_t) i < size ) {
-      return (size_t) i;
-    } else if (insert && ((size_t) i == size)) {
-      return size;
-    }
-    
-    throw std::out_of_range("index out of range");
-  }
-
-  inline size_t
-  slice_index(ptrdiff_t i, size_t size) {
-    if ( i < 0 ) {
-      if ((size_t) (-i) <= size) {
-	return (size_t) (i + size);
-      } else {
-	throw std::out_of_range("index out of range");
-      }
-    } else {
-      return ( (size_t) i < size ) ? ((size_t) i) : size;
-    }
-  }
-
-  template <class Sequence, class Difference>
-  inline typename Sequence::iterator
-  getpos(Sequence* self, Difference i)  {
-    typename Sequence::iterator pos = self->begin();
-    std::advance(pos, check_index(i,self->size()));
-    return pos;
-  }
-
-  template <class Sequence, class Difference>
-  inline typename Sequence::const_iterator
-  cgetpos(const Sequence* self, Difference i)  {
-    typename Sequence::const_iterator pos = self->begin();
-    std::advance(pos, check_index(i,self->size()));
-    return pos;
-  }
-
-  template <class Sequence, class Difference>
-  inline Sequence*
-  getslice(const Sequence* self, Difference i, Difference j) {
-    typename Sequence::size_type size = self->size();
-    typename Sequence::size_type ii = swig::check_index(i, size);
-    typename Sequence::size_type jj = swig::slice_index(j, size);
-
-    if (jj > ii) {
-      typename Sequence::const_iterator vb = self->begin();
-      typename Sequence::const_iterator ve = self->begin();
-      std::advance(vb,ii);
-      std::advance(ve,jj);
-      return new Sequence(vb, ve);
-    } else {
-      return new Sequence();
-    }
-  }
-
-  template <class Sequence, class Difference, class InputSeq>
-  inline void
-  setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) {
-    typename Sequence::size_type size = self->size();
-    typename Sequence::size_type ii = swig::check_index(i, size, true);
-    typename Sequence::size_type jj = swig::slice_index(j, size);
-    if (jj < ii) jj = ii;
-    size_t ssize = jj - ii;
-    if (ssize <= v.size()) {
-      typename Sequence::iterator sb = self->begin();
-      typename InputSeq::const_iterator vmid = v.begin();
-      std::advance(sb,ii);
-      std::advance(vmid, jj - ii);
-      self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
-    } else {
-      typename Sequence::iterator sb = self->begin();
-      typename Sequence::iterator se = self->begin();
-      std::advance(sb,ii);
-      std::advance(se,jj);
-      self->erase(sb,se);
-      self->insert(sb, v.begin(), v.end());
-    }
-  }
-
-  template <class Sequence, class Difference>
-  inline void
-  delslice(Sequence* self, Difference i, Difference j) {
-    typename Sequence::size_type size = self->size();
-    typename Sequence::size_type ii = swig::check_index(i, size, true);
-    typename Sequence::size_type jj = swig::slice_index(j, size);
-    if (jj > ii) {
-      typename Sequence::iterator sb = self->begin();
-      typename Sequence::iterator se = self->begin();
-      std::advance(sb,ii);
-      std::advance(se,jj);
-      self->erase(sb,se);
-    }
-  }
-}
-}
-
-%fragment("OctSequence_Cont","header",
-	  fragment="StdTraits",
-	  fragment="OctSequence_Base",
-	  fragment="OctSwigIterator_T")
-{
-namespace swig
-{
-  template <class T>
-    struct OctSequence_Ref // * octave can't support these, because of how assignment works
-  {
-    OctSequence_Ref(const octave_value& seq, int index)
-      : _seq(seq), _index(index)
-    {
-    }
-    
-    operator T () const
-    {
-      //      swig::SwigVar_PyObject item = OctSequence_GetItem(_seq, _index);
-      octave_value item; // * todo
-      try {
-	return swig::as<T>(item, true);
-      } catch (std::exception& e) {
-	char msg[1024];
-	sprintf(msg, "in sequence element %d ", _index);
-	if (!Octave_Error_Occurred()) {
-	  %type_error(swig::type_name<T>());
-	}
-	SWIG_Octave_AddErrorMsg(msg);
-	SWIG_Octave_AddErrorMsg(e.what());
-	throw;
-      }
-    }
-
-    OctSequence_Ref& operator=(const T& v)
-    {
-      //      OctSequence_SetItem(_seq, _index, swig::from<T>(v));
-      // * todo
-      return *this;
-    }
-
-  private:
-    octave_value _seq;
-    int _index;
-  };
-
-  template <class T>
-  struct OctSequence_ArrowProxy
-  {
-    OctSequence_ArrowProxy(const T& x): m_value(x) {}
-    const T* operator->() const { return &m_value; }
-    operator const T*() const { return &m_value; }
-    T m_value;
-  };
-
-  template <class T, class Reference >
-  struct OctSequence_InputIterator
-  {
-    typedef OctSequence_InputIterator<T, Reference > self;
-
-    typedef std::random_access_iterator_tag iterator_category;
-    typedef Reference reference;
-    typedef T value_type;
-    typedef T* pointer;
-    typedef int difference_type;
-
-    OctSequence_InputIterator()
-    {
-    }
-
-    OctSequence_InputIterator(const octave_value& seq, int index)
-      : _seq(seq), _index(index)
-    {
-    }
-
-    reference operator*() const
-    {
-      return reference(_seq, _index);
-    }
-
-    OctSequence_ArrowProxy<T>
-    operator->() const {
-      return OctSequence_ArrowProxy<T>(operator*());
-    }
-
-    bool operator==(const self& ri) const
-    {
-      return (_index == ri._index);
-    }
-
-    bool operator!=(const self& ri) const
-    {
-      return !(operator==(ri));
-    }
-
-    self& operator ++ ()
-    {
-      ++_index;
-      return *this;
-    }
-
-    self& operator -- ()
-    {
-      --_index;
-      return *this;
-    }
-
-    self& operator += (difference_type n)
-    {
-      _index += n;
-      return *this;
-    }
-
-    self operator +(difference_type n) const
-    {
-      return self(_seq, _index + n);
-    }
-
-    self& operator -= (difference_type n)
-    {
-      _index -= n;
-      return *this;
-    }
-
-    self operator -(difference_type n) const
-    {
-      return self(_seq, _index - n);
-    }
-
-    difference_type operator - (const self& ri) const
-    {
-      return _index - ri._index;
-    }
-
-    bool operator < (const self& ri) const
-    {
-      return _index < ri._index;
-    }
-
-    reference
-    operator[](difference_type n) const
-    {
-      return reference(_seq, _index + n);
-    }
-
-  private:
-    octave_value _seq;
-    difference_type _index;
-  };
-
-  template <class T>
-  struct OctSequence_Cont
-  {
-    typedef OctSequence_Ref<T> reference;
-    typedef const OctSequence_Ref<T> const_reference;
-    typedef T value_type;
-    typedef T* pointer;
-    typedef int difference_type;
-    typedef int size_type;
-    typedef const pointer const_pointer;
-    typedef OctSequence_InputIterator<T, reference> iterator;
-    typedef OctSequence_InputIterator<T, const_reference> const_iterator;
-
-    OctSequence_Cont(const octave_value& seq) : _seq(seq)
-    {
-      // * assert that we have map type etc.
-      /*
-      if (!OctSequence_Check(seq)) {
-	throw std::invalid_argument("a sequence is expected");
-      }
-      _seq = seq;
-      Py_INCREF(_seq);
-      */
-    }
-
-    ~OctSequence_Cont()
-    {
-    }
-
-    size_type size() const
-    {
-      //      return static_cast<size_type>(OctSequence_Size(_seq));
-      return 0; // * todo
-    }
-
-    bool empty() const
-    {
-      return size() == 0;
-    }
-
-    iterator begin()
-    {
-      return iterator(_seq, 0);
-    }
-
-    const_iterator begin() const
-    {
-      return const_iterator(_seq, 0);
-    }
-
-    iterator end()
-    {
-      return iterator(_seq, size());
-    }
-
-    const_iterator end() const
-    {
-      return const_iterator(_seq, size());
-    }
-
-    reference operator[](difference_type n)
-    {
-      return reference(_seq, n);
-    }
-
-    const_reference operator[](difference_type n)  const
-    {
-      return const_reference(_seq, n);
-    }
-
-    bool check(bool set_err = true) const
-    {
-      int s = size();
-      for (int i = 0; i < s; ++i) {
-	//	swig::SwigVar_PyObject item = OctSequence_GetItem(_seq, i);
-	octave_value item; // * todo
-	if (!swig::check<value_type>(item)) {
-	  if (set_err) {
-	    char msg[1024];
-	    sprintf(msg, "in sequence element %d", i);
-	    SWIG_Error(SWIG_RuntimeError, msg);
-	  }
-	  return false;
-	}
-      }
-      return true;
-    }
-
-  private:
-    octave_value _seq;
-  };
-
-}
-}
-
-%define %swig_sequence_iterator(Sequence...)
-#if defined(SWIG_EXPORT_ITERATOR_METHODS)
-  class iterator;
-  class reverse_iterator;
-  class const_iterator;
-  class const_reverse_iterator;
-
-  %typemap(out,noblock=1,fragment="OctSequence_Cont")
-    iterator, reverse_iterator, const_iterator, const_reverse_iterator {
-    $result = SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &)),
-				 swig::OctSwigIterator::descriptor(),SWIG_POINTER_OWN);
-  }
-  %typemap(out,fragment="OctSequence_Cont")
-    std::pair<iterator, iterator>, std::pair<const_iterator, const_iterator> {
-    octave_value_list tmpc;
-    tmpc.append(SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &).first),
-				   swig::OctSwigIterator::descriptor(),SWIG_POINTER_OWN));
-    tmpc.append(SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &).second),
-				   swig::OctSwigIterator::descriptor(),SWIG_POINTER_OWN));
-    $result = Cell(tmpc);
-  }
-
-  %fragment("SwigPyPairBoolOutputIterator","header",fragment=SWIG_From_frag(bool),fragment="OctSequence_Cont") {}
-
-  %typemap(out,fragment="OctPairBoolOutputIterator")
-    std::pair<iterator, bool>, std::pair<const_iterator, bool> {
-    octave_value_list tmpc;
-    tmpc.append(SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &).first),
-				   swig::OctSwigIterator::descriptor(),SWIG_POINTER_OWN));
-    tmpc.append(SWIG_From(bool)(%static_cast($1,const $type &).second));
-    $result = Cell(tmpc);
-  }
-
-  %typemap(in,noblock=1,fragment="OctSequence_Cont")
-    iterator(swig::OctSwigIterator *iter = 0, int res),
-    reverse_iterator(swig::OctSwigIterator *iter = 0, int res),
-    const_iterator(swig::OctSwigIterator *iter = 0, int res),
-    const_reverse_iterator(swig::OctSwigIterator *iter = 0, int res) {
-    res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter), swig::OctSwigIterator::descriptor(), 0);
-    if (!SWIG_IsOK(res) || !iter) {
-      %argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
-    } else {
-      swig::OctSwigIterator_T<$type > *iter_t = dynamic_cast<swig::OctSwigIterator_T<$type > *>(iter);
-      if (iter_t) {
-	$1 = iter_t->get_current();
-      } else {
-	%argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
-      }
-    }
-  }
-
-  %typecheck(%checkcode(ITERATOR),noblock=1,fragment="OctSequence_Cont")
-    iterator, reverse_iterator, const_iterator, const_reverse_iterator {
-    swig::OctSwigIterator *iter = 0;
-    int res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter), swig::OctSwigIterator::descriptor(), 0);
-    $1 = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::OctSwigIterator_T<$type > *>(iter) != 0));
-  }
-
-  %fragment("OctSequence_Cont");
-#endif //SWIG_EXPORT_ITERATOR_METHODS
-%enddef
-
-// The octave container methods
-
-%define %swig_container_methods(Container...)
-%enddef
-
-%define %swig_sequence_methods_common(Sequence...)
-  %swig_sequence_iterator(%arg(Sequence))
-  %swig_container_methods(%arg(Sequence))
-  
-  %fragment("OctSequence_Base");
-
-  %extend {
-    value_type pop() throw (std::out_of_range) {
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      Sequence::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
-
-    value_type __paren__(difference_type i) throw (std::out_of_range) {
-      return *(swig::cgetpos(self, i));
-    }
-
-    void __paren_asgn__(difference_type i, value_type x) throw (std::out_of_range) {
-      *(swig::getpos(self,i)) = x;
-    }
-
-    void append(value_type x) {
-      self->push_back(x);
-    }
-  }
-
-%enddef
-
-%define %swig_sequence_methods(Sequence...)
-  %swig_sequence_methods_common(%arg(Sequence))
-%enddef
-
-%define %swig_sequence_methods_val(Sequence...)
-  %swig_sequence_methods_common(%arg(Sequence))
-%enddef
-
-//
-// Common fragments
-//
-
-%fragment("StdSequenceTraits","header",
-	  fragment="StdTraits",
-	  fragment="OctSequence_Cont")
-{
-namespace swig {
-  template <class OctSeq, class Seq>
-  inline void
-  assign(const OctSeq& octseq, Seq* seq) {
-%#ifdef SWIG_STD_NOASSIGN_STL
-    typedef typename OctSeq::value_type value_type;
-    typename OctSeq::const_iterator it = octseq.begin();
-    for (;it != octseq.end(); ++it) {
-      seq->insert(seq->end(),(value_type)(*it));
-    }
-%#else
-    seq->assign(octseq.begin(), octseq.end());
-%#endif
-  }
-
-  template <class Seq, class T = typename Seq::value_type >
-  struct traits_asptr_stdseq {
-    typedef Seq sequence;
-    typedef T value_type;
-
-    static int asptr(const octave_value& obj, sequence **seq) {
-      if (!obj.is_defined() || Swig::swig_value_deref(obj)) {
-	sequence *p;
-	if (SWIG_ConvertPtr(obj,(void**)&p,
-			    swig::type_info<sequence>(),0) == SWIG_OK) {
-	  if (seq) *seq = p;
-	  return SWIG_OLDOBJ;
-	}
-      } else if (obj.is_cell()) {
-	try {
-	  OctSequence_Cont<value_type> octseq(obj);
-	  if (seq) {
-	    sequence *pseq = new sequence();
-	    assign(octseq, pseq);
-	    *seq = pseq;
-	    return SWIG_NEWOBJ;
-	  } else {
-	    return octseq.check() ? SWIG_OK : SWIG_ERROR;
-	  }
-	} catch (std::exception& e) {
-	  if (seq&&!error_state)
-	    error("swig type error: %s",e.what());
-	  return SWIG_ERROR;
-	}
-      }
-      return SWIG_ERROR;
-    }
-  };
-
-  template <class Seq, class T = typename Seq::value_type >
-  struct traits_from_stdseq {
-    typedef Seq sequence;
-    typedef T value_type;
-    typedef typename Seq::size_type size_type;
-    typedef typename sequence::const_iterator const_iterator;
-
-    static octave_value from(const sequence& seq) {
-#ifdef SWIG_OCTAVE_EXTRA_NATIVE_CONTAINERS
-      swig_type_info *desc = swig::type_info<sequence>();
-      if (desc && desc->clientdata) {
-	return SWIG_NewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
-      }
-#endif
-      size_type size = seq.size();
-      if (size <= (size_type)INT_MAX) {
-	Cell c(size,1);
-	int i = 0;
-	for (const_iterator it = seq.begin();
-	     it != seq.end(); ++it, ++i) {
-	  c(i) = swig::from<value_type>(*it);
-	}
-	return c;
-      } else {
-	error("swig overflow error: sequence size not valid in octave");
-	return octave_value();
-      }
-      return octave_value();
-    }
-  };
-}
-}
-
diff --git a/share/swig/2.0.11/octave/octopers.swg b/share/swig/2.0.11/octave/octopers.swg
deleted file mode 100644
index c38e64d..0000000
--- a/share/swig/2.0.11/octave/octopers.swg
+++ /dev/null
@@ -1,88 +0,0 @@
-/* ------------------------------------------------------------
- * Overloaded operator support
- * ------------------------------------------------------------ */
-
-#ifdef __cplusplus
-
-// operators supported in Octave, and the methods they are routed to
-
-// __brace__      a{args}
-// __brace_asgn__ a{args} = rhs
-// __paren__      a(args)
-// __paren_asgn__ a(args) = rhs
-// __str__        generates string rep
-
-// __not__        !a
-// __uplus__      +a
-// __uminus__     -a
-// __transpose__  a.'
-// __hermitian__  a'
-// __incr__       a++
-// __decr__       a--
-// __add__        a + b
-// __sub__        a - b
-// __mul__        a * b
-// __div__        a / b
-// __pow__        a ^ b
-// __ldiv__       a \ b
-// __lshift__     a << b
-// __rshift__     a >> b
-// __lt__         a < b
-// __le__         a <= b
-// __eq__         a == b
-// __ge__         a >= b
-// __gt__         a > b
-// __ne__         a != b
-// __el_mul__     a .* b
-// __el_div__     a ./ b
-// __el_pow__     a .^ b
-// __el_ldiv__    a .\ b
-// __el_and__     a & b
-// __el_or__      a | b
-
-// operators supported in C++, and the methods that route to them
-
-%rename(__add__)       *::operator+;
-%rename(__add__)       *::operator+();
-%rename(__add__)       *::operator+() const;
-%rename(__sub__)       *::operator-;
-%rename(__uminus__)    *::operator-();
-%rename(__uminus__)    *::operator-() const;
-%rename(__mul__)       *::operator*;
-%rename(__div__)       *::operator/;
-%rename(__mod__)       *::operator%;
-%rename(__lshift__)    *::operator<<;
-%rename(__rshift__)    *::operator>>;
-%rename(__el_and__)    *::operator&&;
-%rename(__el_or__)     *::operator||;
-%rename(__xor__)       *::operator^;
-%rename(__invert__)    *::operator~;
-%rename(__lt__)        *::operator<;
-%rename(__le__)        *::operator<=;
-%rename(__gt__)        *::operator>;
-%rename(__ge__)        *::operator>=;
-%rename(__eq__)        *::operator==;
-%rename(__ne__)        *::operator!=;
-%rename(__not__)       *::operator!;
-%rename(__incr__)      *::operator++;
-%rename(__decr__)      *::operator--;
-%rename(__paren__)     *::operator();
-%rename(__brace__)     *::operator[];
-
-// Ignored inplace operators
-%ignoreoperator(PLUSEQ)     operator+=;
-%ignoreoperator(MINUSEQ)    operator-=;
-%ignoreoperator(MULEQ)      operator*=;
-%ignoreoperator(DIVEQ)      operator/=;
-%ignoreoperator(MODEQ)      operator%=;
-%ignoreoperator(LSHIFTEQ)   operator<<=;
-%ignoreoperator(RSHIFTEQ)   operator>>=;
-%ignoreoperator(ANDEQ)      operator&=;
-%ignoreoperator(OREQ)       operator|=;
-%ignoreoperator(XOREQ)      operator^=;
-
-// Ignored operators
-%ignoreoperator(EQ)         operator=;
-%ignoreoperator(ARROWSTAR)  operator->*;
-
-#endif /* __cplusplus */
diff --git a/share/swig/2.0.11/octave/octprimtypes.swg b/share/swig/2.0.11/octave/octprimtypes.swg
deleted file mode 100644
index 6f43f21..0000000
--- a/share/swig/2.0.11/octave/octprimtypes.swg
+++ /dev/null
@@ -1,232 +0,0 @@
-/* ------------------------------------------------------------
- * Primitive Types
- * ------------------------------------------------------------ */
-
-
-// boolean
-
-%fragment(SWIG_From_frag(bool),"header") {
-SWIGINTERNINLINE octave_value
-  SWIG_From_dec(bool)(bool value)
-{
-  return octave_value(value);
-}
-}
-
-%fragment(SWIG_AsVal_frag(bool),"header",
-	  fragment=SWIG_AsVal_frag(long)) {
-SWIGINTERN int
-SWIG_AsVal_dec(bool)(const octave_value& ov, bool *val)
-{
-  if (!ov.is_bool_type())
-    return SWIG_ERROR;
-  if (val)
-    *val = ov.bool_value();
-  return SWIG_OK;
-}
-}
-
-// long
-
-%fragment(SWIG_From_frag(long),"header") {
-  SWIGINTERNINLINE octave_value SWIG_From_dec(long)  (long value)
-    {    
-      return octave_value(value);
-    }
-}
-
-
-%fragment(SWIG_AsVal_frag(long),"header") {
-  SWIGINTERN int SWIG_AsVal_dec(long)(const octave_value& ov, long* val)
-    {
-      if (!ov.is_scalar_type())
-	return SWIG_TypeError;
-      if (ov.is_complex_scalar())
-	return SWIG_TypeError;
-      if (ov.is_double_type()||ov.is_single_type()) {
-	double v=ov.double_value();
-	if (v!=floor(v))
-	  return SWIG_TypeError;
-      }
-      if (val)
-	*val = ov.long_value();
-      return SWIG_OK;
-    }
-}
-
-// unsigned long
-
-%fragment(SWIG_From_frag(unsigned long),"header") {
-  SWIGINTERNINLINE octave_value SWIG_From_dec(unsigned long)  (unsigned long value)
-    {    
-      return octave_value(value);
-    }
-}
-
-
-%fragment(SWIG_AsVal_frag(unsigned long),"header") {
-  SWIGINTERN int SWIG_AsVal_dec(unsigned long)(const octave_value& ov, unsigned long* val)
-    {
-      if (!ov.is_scalar_type())
-	return SWIG_TypeError;
-      if (ov.is_complex_scalar())
-	return SWIG_TypeError;
-      if (ov.is_double_type()||ov.is_single_type()) {
-	double v=ov.double_value();
-	if (v<0)
-	  return SWIG_OverflowError;  
-	if (v!=floor(v))
-	  return SWIG_TypeError;
-      }
-      if (ov.is_int8_type()||ov.is_int16_type()||
-	  ov.is_int32_type()) {
-	long v=ov.long_value();
-	if (v<0)
-	  return SWIG_OverflowError;  
-      }
-      if (ov.is_int64_type()) {
-	long long v=ov.int64_scalar_value().value();
-	if (v<0)
-	  return SWIG_OverflowError;  
-      }
-      if (val)
-	*val = ov.ulong_value();
-      return SWIG_OK;
-    }
-}
-
-// long long
-
-%fragment(SWIG_From_frag(long long),"header") {
-  SWIGINTERNINLINE octave_value SWIG_From_dec(long long)  (long long value)
-    {    
-      return octave_int64(value);
-    }
-}
-
-
-%fragment(SWIG_AsVal_frag(long long),"header") {
-  SWIGINTERN int SWIG_AsVal_dec(long long)(const octave_value& ov, long long* val)
-    {
-      if (!ov.is_scalar_type())
-	return SWIG_TypeError;
-      if (ov.is_complex_scalar())
-	return SWIG_TypeError;
-      if (ov.is_double_type()||ov.is_single_type()) {
-	double v=ov.double_value();
-	if (v!=floor(v))
-	  return SWIG_TypeError;
-      }
-      if (val) {
-	if (ov.is_int64_type())
-	  *val = ov.int64_scalar_value().value();
-	else if (ov.is_uint64_type())
-	  *val = ov.uint64_scalar_value().value();
-	else
-	  *val = ov.long_value();
-      }
-      return SWIG_OK;
-    }
-}
-
-%fragment(SWIG_From_frag(unsigned long long),"header") {
-  SWIGINTERNINLINE octave_value SWIG_From_dec(unsigned long long)  (unsigned long long value)
-    {    
-      return octave_uint64(value);
-    }
-}
-
-%fragment(SWIG_AsVal_frag(unsigned long long),"header") {
-  SWIGINTERN int SWIG_AsVal_dec(unsigned long long)(const octave_value& ov, unsigned long long* val)
-    {
-      if (!ov.is_scalar_type())
-	return SWIG_TypeError;
-      if (ov.is_complex_scalar())
-	return SWIG_TypeError;
-      if (ov.is_double_type()||ov.is_single_type()) {
-	double v=ov.double_value();
-	if (v<0)
-	  return SWIG_OverflowError;  
-	if (v!=floor(v))
-	  return SWIG_TypeError;
-      }
-      if (ov.is_int8_type()||ov.is_int16_type()||
-	  ov.is_int32_type()) {
-	long v=ov.long_value();
-	if (v<0)
-	  return SWIG_OverflowError;  
-      }
-      if (ov.is_int64_type()) {
-	long long v=ov.int64_scalar_value().value();
-	if (v<0)
-	  return SWIG_OverflowError;  
-      }
-      if (val) {
-	if (ov.is_int64_type())
-	  *val = ov.int64_scalar_value().value();
-	else if (ov.is_uint64_type())
-	  *val = ov.uint64_scalar_value().value();
-	else
-	  *val = ov.long_value();
-      }
-      return SWIG_OK;
-    }
-}
-
-// double
-
-%fragment(SWIG_From_frag(double),"header") {
-  SWIGINTERNINLINE octave_value SWIG_From_dec(double)  (double value)
-    {    
-      return octave_value(value);
-    }
-}
-
-
-%fragment(SWIG_AsVal_frag(double),"header") {
-  SWIGINTERN int SWIG_AsVal_dec(double)(const octave_value& ov, double* val)
-    {
-      if (!ov.is_scalar_type())
-	return SWIG_TypeError;
-      if (ov.is_complex_scalar())
-	return SWIG_TypeError;
-      if (val)
-	*val = ov.double_value();
-      return SWIG_OK;
-    }
-}
-
-// const char* (strings)
-
-%fragment("SWIG_AsCharPtrAndSize","header") {
-SWIGINTERN int
-SWIG_AsCharPtrAndSize(octave_value ov, char** cptr, size_t* psize, int *alloc)
-{
-  if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
-    ov = ov.cell_value()(0);
-  if (!ov.is_string())
-    return SWIG_TypeError;
-  
-  std::string str=ov.string_value();
-  size_t len=str.size();
-  char* cstr=(char*)str.c_str();
-  if (alloc) {
-    *cptr = %new_copy_array(cstr, len + 1, char);
-    *alloc = SWIG_NEWOBJ;
-  } else if (cptr)
-    *cptr = cstr;
-  if (psize)
-    *psize = len + 1;
-  return SWIG_OK;
-}
-}
-
-%fragment("SWIG_FromCharPtrAndSize","header",fragment="SWIG_pchar_descriptor") {
-SWIGINTERNINLINE octave_value
-SWIG_FromCharPtrAndSize(const char* carray, size_t size)
-{
-  return std::string(carray,carray+size);
-}
-}
-
-
diff --git a/share/swig/2.0.11/octave/octrun.swg b/share/swig/2.0.11/octave/octrun.swg
deleted file mode 100644
index 41d1c7a..0000000
--- a/share/swig/2.0.11/octave/octrun.swg
+++ /dev/null
@@ -1,1319 +0,0 @@
-
-#include <octave/version.h>
-#ifndef OCTAVE_API_VERSION_NUMBER
-
-  // Hack to distinguish between Octave 3.2 and earlier versions before OCTAVE_API_VERSION_NUMBER existed
-  #define ComplexLU __ignore
-  #include <octave/CmplxLU.h>
-  #undef ComplexLU
-  #ifdef octave_Complex_LU_h
-  # define OCTAVE_API_VERSION_NUMBER 36
-  #else
-  # define OCTAVE_API_VERSION_NUMBER 37
-  #endif
-
-#endif
-
-#if OCTAVE_API_VERSION_NUMBER < 37
-#define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
-#else
-#define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
-#endif
-
-SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs) {
-  if (num_args > max_args && !varargs)
-    error("function %s takes at most %i arguments", func_name, max_args);
-  else if (num_args < min_args)
-    error("function %s requires at least %i arguments", func_name, min_args);
-  else
-    return true;
-  return false;
-}
-
-SWIGRUNTIME octave_value_list *SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov) {
-  ovl->append(ov);
-  return ovl;
-}
-
-SWIGRUNTIME octave_value SWIG_ErrorType(int code) {
-  switch (code) {
-  case SWIG_MemoryError:
-    return "SWIG_MemoryError";
-  case SWIG_IOError:
-    return "SWIG_IOError";
-  case SWIG_RuntimeError:
-    return "SWIG_RuntimeError";
-  case SWIG_IndexError:
-    return "SWIG_IndexError";
-  case SWIG_TypeError:
-    return "SWIG_TypeError";
-  case SWIG_DivisionByZero:
-    return "SWIG_DivisionByZero";
-  case SWIG_OverflowError:
-    return "SWIG_OverflowError";
-  case SWIG_SyntaxError:
-    return "SWIG_SyntaxError";
-  case SWIG_ValueError:
-    return "SWIG_ValueError";
-  case SWIG_SystemError:
-    return "SWIG_SystemError";
-  case SWIG_AttributeError:
-    return "SWIG_AttributeError";
-  }
-  return "SWIG unknown error";
-}
-
-SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg) {
-  octave_value type(SWIG_ErrorType(code));
-  std::string r = msg;
-  r += " (" + type.string_value() + ")";
-  error(r.c_str());
-  return octave_value(r);
-}
-
-#define SWIG_fail                                       goto fail
-
-#define SWIG_Octave_ConvertPtr(obj, pptr, type, flags)  SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
-#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
-#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
-#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
-#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Octave_NewPointerObj(ptr, type, flags)
-#define swig_owntype                                    int
-
-#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
-#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Octave_NewPackedObj(ptr, sz, type)
-
-#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
-#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
-
-#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
-#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Octave_NewPackedObj(ptr, sz, type)
-
-#define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
-#define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
-#define SWIG_MODULE_CLIENTDATA_TYPE void*
-
-#define Octave_Error_Occurred() 0
-#define SWIG_Octave_AddErrorMsg(msg) {;}
-
-SWIGRUNTIME swig_module_info *SWIG_Octave_GetModule(void *clientdata);
-SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer);
-
-// For backward compatibility only
-#define SWIG_POINTER_EXCEPTION  0
-#define SWIG_arg_fail(arg)      0
-
-// Runtime API implementation
-
-#include <map>
-#include <vector>
-#include <string>
-
-typedef octave_value_list(*octave_func) (const octave_value_list &, int);
-class octave_swig_type;
-
-namespace Swig {
-
-#ifdef SWIG_DIRECTORS
-
-  class Director;
-
-  typedef std::map < void *, Director * > rtdir_map;
-  SWIGINTERN rtdir_map* get_rtdir_map();
-  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *d);
-  SWIGINTERNINLINE void erase_rtdir(void *vptr);
-  SWIGINTERNINLINE Director *get_rtdir(void *vptr);
-
-  SWIGRUNTIME void swig_director_destroyed(octave_swig_type *self, Director *d);
-  SWIGRUNTIME octave_swig_type *swig_director_get_self(Director *d);
-  SWIGRUNTIME void swig_director_set_self(Director *d, octave_swig_type *self);
-
-#endif
-
-  SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost);
-  SWIGRUNTIME octave_swig_type *swig_value_deref(octave_value ov);
-  SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov);
-}
-
-#ifdef SWIG_DIRECTORS
-SWIGRUNTIME void swig_acquire_ownership(void *vptr);
-SWIGRUNTIME void swig_acquire_ownership_array(void *vptr);
-SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
-#endif
-
-  struct swig_octave_member {
-    const char *name;
-    octave_func method;
-    octave_func get_method;
-    octave_func set_method;
-    int flags;			// 1 static, 2 global
-    const char *doc;
-    bool is_static() const {
-      return flags &1;
-    } bool is_global() const {
-      return flags &2;
-    }
-  };
-
-  struct swig_octave_class {
-    const char *name;
-    swig_type_info **type;
-    int director;
-    octave_func constructor;
-    const char *constructor_doc;
-    octave_func destructor;
-    const swig_octave_member *members;
-    const char **base_names;
-    const swig_type_info **base;
-  };
-
-  // octave_swig_type plays the role of both the shadow class and the class 
-  // representation within Octave, since there is no support for classes.
-  //
-  // These should really be decoupled, with the class support added to Octave
-  // and the shadow class given by an m-file script. That would dramatically 
-  // reduce the runtime complexity, and be more in line w/ other modules.
-
-  class octave_swig_type:public octave_base_value {
-    struct cpp_ptr {
-      void *ptr;
-      bool destroyed;
-      cpp_ptr(void *_ptr):ptr(_ptr), destroyed(false) {
-      }};
-    typedef std::pair < const swig_type_info *, cpp_ptr > type_ptr_pair;
-
-    mutable swig_module_info *module;
-
-    const swig_type_info *construct_type;	// type of special type object
-    std::vector < type_ptr_pair > types;	// our c++ base classes
-    int own;			// whether we call c++ destructors when we die
-
-    typedef std::pair < const swig_octave_member *, octave_value > member_value_pair;
-    typedef std::map < std::string, member_value_pair > member_map;
-    member_map members;
-    bool always_static;
-
-    const swig_octave_member *find_member(const swig_type_info *type, const std::string &name) {
-      if (!type->clientdata)
-	return 0;
-      swig_octave_class *c = (swig_octave_class *) type->clientdata;
-      const swig_octave_member *m;
-      for (m = c->members; m->name; ++m)
-	if (m->name == name)
-	  return m;
-      for (int j = 0; c->base_names[j]; ++j) {
-	if (!c->base[j]) {
-	  if (!module)
-	    module = SWIG_GetModule(0);
-	  assert(module);
-	  c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
-	}
-	if (!c->base[j])
-	  return 0;
-	if ((m = find_member(c->base[j], name)))
-	  return m;
-      }
-      return 0;
-    }
-
-    member_value_pair *find_member(const std::string &name, bool insert_if_not_found) {
-      member_map::iterator it = members.find(name);
-      if (it != members.end())
-	return &it->second;
-      const swig_octave_member *m;
-      for (unsigned int j = 0; j < types.size(); ++j)
-	if ((m = find_member(types[j].first, name)))
-	  return &members.insert(std::make_pair(name, std::make_pair(m, octave_value()))).first->second;
-      if (!insert_if_not_found)
-	return 0;
-      return &members[name];
-    }
-
-    const swig_type_info *find_base(const std::string &name, const swig_type_info *base) {
-      if (!base) {
-	for (unsigned int j = 0; j < types.size(); ++j) {
-	  assert(types[j].first->clientdata);
-	  swig_octave_class *cj = (swig_octave_class *) types[j].first->clientdata;
-	  if (cj->name == name)
-	    return types[j].first;
-	}
-	return 0;
-      }
-      assert(base->clientdata);
-      swig_octave_class *c = (swig_octave_class *) base->clientdata;
-      for (int j = 0; c->base_names[j]; ++j) {
-	if (!c->base[j]) {
-	  if (!module)
-	    module = SWIG_GetModule(0);
-	  assert(module);
-	  c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
-	}
-	if (!c->base[j])
-	  return 0;
-	assert(c->base[j]->clientdata);
-	swig_octave_class *cj = (swig_octave_class *) c->base[j]->clientdata;
-	if (cj->name == name)
-	  return c->base[j];
-      }
-      return 0;
-    }
-
-    void load_members(const swig_octave_class* c,member_map& out) const {
-      for (const swig_octave_member *m = c->members; m->name; ++m) {
-	if (out.find(m->name) == out.end())
-	  out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
-      }
-      for (int j = 0; c->base_names[j]; ++j) {
-	if (!c->base[j]) {
-	  if (!module)
-	    module = SWIG_GetModule(0);
-	  assert(module);
-	  c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
-	}
-	if (!c->base[j])
-	  continue;
-	assert(c->base[j]->clientdata);
-	const swig_octave_class *cj =
-	  (const swig_octave_class *) c->base[j]->clientdata;
-	load_members(cj,out);
-      }
-    }
-
-    void load_members(member_map& out) const {
-      out=members;
-      for (unsigned int j = 0; j < types.size(); ++j)
-	if (types[j].first->clientdata)
-	  load_members((const swig_octave_class *) types[j].first->clientdata, out);
-    }
-
-    octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout) {
-      if (m->second.is_defined())
-	return m->second.subsref("(", std::list < octave_value_list > (1, args), nargout);
-      else if (m->first && m->first->method)
-	return m->first->method(args, nargout);
-      error("member not defined or not invocable");
-      return octave_value_list();
-    }
-
-    bool dispatch_unary_op(const std::string &symbol, octave_value &ret) {
-      member_value_pair *m = find_member(symbol, false);
-      if (!m || m->first->is_static() || m->first->is_global())
-	return false;
-      octave_value_list args;
-      args.append(as_value());
-      octave_value_list argout(member_invoke(m, args, 1));
-      if (argout.length() < 1)
-	return false;
-      ret = argout(0);
-      return true;
-    }
-
-    bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) {
-      member_value_pair *m = find_member(symbol, false);
-      if (!m || m->first->is_static() || m->first->is_global())
-	return false;
-      octave_value_list args;
-      args.append(as_value());
-      args.append(make_value_hack(rhs));
-      octave_value_list argout(member_invoke(m, args, 1));
-      if (argout.length() < 1)
-	return false;
-      ret = argout(0);
-      return true;
-    }
-
-    bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) {
-      member_value_pair *m = find_member(symbol, false);
-      if (!m || m->first->is_static() || m->first->is_global())
-	return false;
-      octave_value_list args;
-      args.append(as_value());
-      args.append(rhs);
-      octave_value_list argout(member_invoke(m, args, 1));
-      if (argout.length() >= 1)
-	ret = argout(0);
-      return true;
-    }
-
-    octave_value_list member_deref(member_value_pair *m, const octave_value_list &args) {
-      if (m->second.is_defined())
-	return m->second;
-      else if (m->first) {
-	if (m->first->get_method)
-	  return m->first->get_method(args, 1);
-	else if (m->first->method)
-	  return octave_value(new octave_builtin(m->first->method));
-      }
-      error("undefined member");
-      return octave_value_list();
-    }
-
-    static octave_value make_value_hack(const octave_base_value &x) {
-      ((octave_swig_type &) x).count++;
-      return octave_value((octave_base_value *) &x);
-    }
-
-    octave_swig_type(const octave_swig_type &x);
-    octave_swig_type &operator=(const octave_swig_type &rhs);
-  public:
-
-    octave_swig_type(void *_ptr = 0, const swig_type_info *_type = 0, int _own = 0,
-		     bool _always_static = false)
-      :	module(0), construct_type(_ptr ? 0 : _type), own(_own), 
-      always_static(_always_static) {
-      if (_type || _ptr)
-	types.push_back(std::make_pair(_type, _ptr));
-#ifdef SWIG_DIRECTORS
-      if (_ptr) {
-	Swig::Director *d = Swig::get_rtdir(_ptr);
-	if (d)
-	  Swig::swig_director_set_self(d, this);
-      }
-#endif
-    }
-
-    ~octave_swig_type() {
-      if (own) {
-	++count;
-	for (unsigned int j = 0; j < types.size(); ++j) {
-	  if (!types[j].first || !types[j].first->clientdata)
-	    continue;
-	  swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
-	  if (c->destructor && !types[j].second.destroyed && types[j].second.ptr) {
-	    c->destructor(as_value(), 0);
-	  }
-	}
-      }
-#ifdef SWIG_DIRECTORS
-      for (unsigned int j = 0; j < types.size(); ++j)
-	Swig::erase_rtdir(types[j].second.ptr);
-#endif
-    }
-
-    dim_vector dims(void) const {
-      octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
-      
-      // Find the __dims__ method of this object
-      member_value_pair *m = nc_this->find_member("__dims__", false);
-
-      if (!m) return dim_vector(1,1);
-      
-      // Call the __dims__ method of this object
-      octave_value_list inarg;
-      inarg.append(nc_this->as_value());
-      octave_value_list outarg = nc_this->member_invoke(m, inarg, 1);
-
-      // __dims__ should return (at least) one output argument
-      if (outarg.length() < 1) return dim_vector(1,1);
-      
-      octave_value & out = outarg(0);
-
-      // Return value should be cell or matrix of integers
-      if (out.is_cell()) {
-        const Cell & c=out.cell_value();
-        int ndim = c.rows();
-        if (ndim==1 && c.columns()!=1) ndim = c.columns();
-
-        dim_vector d;
-        d.resize(ndim < 2 ? 2 : ndim);
-        d(0) = d(1) = 1;
-
-        // Fill in dim_vector 
-        for (int k=0;k<ndim;k++) {
-          const octave_value& obj = c(k);
-          d.elem(k) = obj.int_value();
-          
-          // __dims__ should return a cell filled with integers
-          if (error_state) return dim_vector(1,1);
-        }
-        return d;
-      } else if (out.is_matrix_type() || out.is_real_nd_array() || out.is_numeric_type() ) {
-        if (out.rows()==1 || out.columns()==1) {
-           Array<int> a = out.int_vector_value();
-           if (error_state) return dim_vector(1,1);
-           dim_vector d;
-           d.resize(a.numel() < 2 ? 2 : a.numel());
-           d(0) = d(1) = 1;
-           for (int k=0;k<a.numel();k++) {
-              d.elem(k) = a(k);
-           }
-           return d;
-        } else {
-          return dim_vector(1,1);
-        }
-      } else {
-        return dim_vector(1,1);
-      }
-    }
-
-    octave_value as_value() {
-      ++count;
-      return Swig::swig_value_ref(this);
-    }
-
-    void incref() {
-      ++count;
-    }
-
-    void decref() {
-      if (!--count)
-	delete this;
-    }
-
-    long swig_this() const {
-      if (!types.size())
-	return (long) this;
-      return (long) types[0].second.ptr;
-    }
-    const char* help_text() const {
-      if (!types.size())
-	return 0;
-      if (!types[0].first->clientdata)
-	return 0;
-      swig_octave_class *c = (swig_octave_class *) types[0].first->clientdata;
-      return c->constructor_doc;
-    }
-
-    std::string swig_type_name() const {
-      // * need some way to manually name subclasses.
-      // * eg optional first arg to subclass(), or named_subclass()
-      std::string ret;
-      for (unsigned int j = 0; j < types.size(); ++j) {
-	if (j)
-	  ret += "_";
-	if (types[j].first->clientdata) {
-	  swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
-	  ret += c->name;
-	} else
-	  ret += types[j].first->name;
-      }
-      return ret;
-    }
-
-    void merge(octave_swig_type &rhs) {
-      rhs.own = 0;
-      for (unsigned int j = 0; j < rhs.types.size(); ++j) {
-	assert(!rhs.types[j].second.destroyed);
-#ifdef SWIG_DIRECTORS
-	Swig::Director *d = Swig::get_rtdir(rhs.types[j].second.ptr);
-	if (d)
-	  Swig::swig_director_set_self(d, this);
-#endif
-      }
-      types.insert(types.end(), rhs.types.begin(), rhs.types.end());
-      members.insert(rhs.members.begin(), rhs.members.end());
-      rhs.types.clear();
-      rhs.members.clear();
-    }
-
-    typedef member_map::const_iterator swig_member_const_iterator;
-    swig_member_const_iterator swig_members_begin() { return members.begin(); }
-    swig_member_const_iterator swig_members_end() { return members.end(); }
-
-    void *cast(swig_type_info *type, int *_own, int flags) {
-      if (_own)
-	*_own = own;
-      if (flags &SWIG_POINTER_DISOWN)
-	own = 0;
-      if (!type && types.size())
-	return types[0].second.ptr;
-      for (unsigned int j = 0; j < types.size(); ++j)
-	if (type == types[j].first)
-	  return types[j].second.ptr;
-      for (unsigned int j = 0; j < types.size(); ++j) {
-	swig_cast_info *tc = SWIG_TypeCheck(types[j].first->name, type);
-	if (!tc)
-	  continue;
-	int newmemory = 0;
-	void *vptr = SWIG_TypeCast(tc, types[j].second.ptr, &newmemory);
-	assert(!newmemory);	// newmemory handling not yet implemented
-	return vptr;
-      }
-      return 0;
-    }
-
-    bool is_owned() const {
-      return own;
-    }
-
-#ifdef SWIG_DIRECTORS
-    void director_destroyed(Swig::Director *d) {
-      bool found = false;
-      for (unsigned int j = 0; j < types.size(); ++j) {
-	Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
-	if (dj == d) {
-	  types[j].second.destroyed = true;
-	  found = true;
-	}
-      }
-      assert(found);
-    }
-#endif
-
-    void assign(const std::string &name, const octave_value &ov) {
-      members[name] = std::make_pair((const swig_octave_member *) 0, ov);
-    }
-
-    void assign(const std::string &name, const swig_octave_member *m) {
-      members[name] = std::make_pair(m, octave_value());
-    }
-
-    octave_base_value *clone() const {
-      // pass-by-value is probably not desired, and is harder;
-      // requires calling copy constructors of contained types etc.
-      assert(0);
-      *(int *) 0 = 0;
-      return 0;
-    }
-
-    octave_base_value *empty_clone() const {
-      return new octave_swig_type();
-    }
-
-    bool is_defined() const {
-      return true;
-    }
-
-    virtual bool is_map() const {
-      return true;
-    }
-
-    virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
-      octave_value_list ovl = subsref(ops, idx, 1);
-      return ovl.length()? ovl(0) : octave_value();
-    }
-
-    virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
-      assert(ops.size() > 0);
-      assert(ops.size() == idx.size());
-
-      std::list < octave_value_list >::const_iterator idx_it = idx.begin();
-      int skip = 0;
-      octave_value_list sub_ovl;
-
-      // constructor invocation
-      if (ops[skip] == '(' && construct_type) {
-	assert(construct_type->clientdata);
-	swig_octave_class *c = (swig_octave_class *) construct_type->clientdata;
-	if (!c->constructor) {
-	  error("cannot create instance");
-	  return octave_value_list();
-	}
-	octave_value_list args;
-	if (c->director)
-	  args.append(Swig::swig_value_ref(new octave_swig_type(this, 0, 0)));
-	args.append(*idx_it++);
-	++skip;
-	sub_ovl = c->constructor(args, nargout);
-      }
-      // member dereference or invocation
-      else if (ops[skip] == '.') {
-	std::string subname;
-	const swig_type_info *base = 0;	// eg, a.base.base_cpp_mem
-	for (;;) {
-	  octave_value_list subname_ovl(*idx_it++);
-	  ++skip;
-	  assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
-	  subname = subname_ovl(0).string_value();
-
-	  const swig_type_info *next_base = find_base(subname, base);
-	  if (!next_base || skip >= (int) ops.size() || ops[skip] != '.')
-	    break;
-	  base = next_base;
-	}
-
-	member_value_pair tmp, *m = &tmp;
-	if (!base || !(m->first = find_member(base, subname)))
-	  m = find_member(subname, false);
-	if (!m) {
-	  error("member not found");
-	  return octave_value_list();
-	}
-
-	octave_value_list args;
-	if (!always_static &&
-	    (!m->first || (!m->first->is_static() && !m->first->is_global())))
-	  args.append(as_value());
-	if (skip < (int) ops.size() && ops[skip] == '(' && 
-	    ((m->first && m->first->method) || m->second.is_function() || 
-	     m->second.is_function_handle())) {
-	  args.append(*idx_it++);
-	  ++skip;
-	  sub_ovl = member_invoke(m, args, nargout);
-	} else {
-	  sub_ovl = member_deref(m, args);
-	}
-      }
-      // index operator
-      else {
-	if (ops[skip] == '(' || ops[skip] == '{') {
-	  const char *op_name = ops[skip] == '(' ? "__paren__" : "__brace__";
-	  octave_value_list args;
-	  args.append(*idx_it++);
-	  ++skip;
-	  if (!dispatch_index_op(op_name, args, sub_ovl)) {
-	    error("error evaluating index operator");
-	    return octave_value_list();
-	  }
-	} else {
-	  error("unsupported subsref");
-	  return octave_value_list();
-	}
-      }
-
-      if (skip >= (int) ops.size())
-	return sub_ovl;
-      if (sub_ovl.length() < 1) {
-	error("bad subs ref");
-	return octave_value_list();
-      }
-      return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
-    }
-
-    octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs) {
-      assert(ops.size() > 0);
-      assert(ops.size() == idx.size());
-
-      std::list < octave_value_list >::const_iterator idx_it = idx.begin();
-      int skip = 0;
-
-      if (ops.size() > 1) {
-	std::list < octave_value_list >::const_iterator last = idx.end();
-	--last;
-	std::list < octave_value_list > next_idx(idx.begin(), last);
-	octave_value next_ov = subsref(ops.substr(0, ops.size() - 1), next_idx);
-	next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
-      }
-
-      else if (ops[skip] == '(' || ops[skip] == '{') {
-	const char *op_name = ops[skip] == '(' ? "__paren_asgn__" : "__brace_asgn__";
-	member_value_pair *m = find_member(op_name, false);
-	if (m) {
-	  octave_value_list args;
-	  args.append(as_value());
-	  args.append(*idx_it);
-	  args.append(rhs);
-	  member_invoke(m, args, 1);
-	} else
-	  error("%s member not found", op_name);
-      }
-
-      else if (ops[skip] == '.') {
-	octave_value_list subname_ovl(*idx_it++);
-	++skip;
-	assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
-	std::string subname = subname_ovl(0).string_value();
-
-	member_value_pair *m = find_member(subname, true);
-	if (!m->first || !m->first->set_method) {
-	  m->first = 0;
-	  m->second = rhs;
-	} else if (m->first->set_method) {
-	  octave_value_list args;
-	  if (!m->first->is_static() && !m->first->is_global())
-	    args.append(as_value());
-	  args.append(rhs);
-	  m->first->set_method(args, 1);
-	} else
-	  error("member not assignable");
-      } else
-	error("unsupported subsasgn");
-
-      return as_value();
-    }
-
-    virtual bool is_object() const {
-      return true;
-    }
-
-    virtual bool is_string() const {
-      octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
-      return !!nc_this->find_member("__str__", false);
-    }
-
-    virtual std::string string_value(bool force = false) const {
-      octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
-      member_value_pair *m = nc_this->find_member("__str__", false);
-      if (!m) {
-	error("__str__ method not defined");
-	return std::string();
-      }
-      octave_value_list outarg = nc_this->member_invoke(m, octave_value_list(nc_this->as_value()), 1);
-      if (outarg.length() < 1 || !outarg(0).is_string()) {
-	error("__str__ method did not return a string");
-	return std::string();
-      }
-      return outarg(0).string_value();
-    }
-
-#if OCTAVE_API_VERSION_NUMBER >= 40
-    virtual octave_map map_value() const {
-      return octave_map();
-    }
-#else
-    virtual Octave_map map_value() const {
-      return Octave_map();
-    }
-#endif
-
-    virtual string_vector map_keys() const {
-      member_map tmp;
-      load_members(tmp);
-
-      string_vector keys(tmp.size());
-      int k = 0;
-      for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
-	keys(k++) = it->first;
-
-      return keys;
-    }
-
-    virtual bool save_ascii (std::ostream& os) {
-      return true;
-    }
-
-    virtual bool load_ascii (std::istream& is) {
-      return true;
-    }
-
-    virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
-      return true;
-    }
-
-    virtual bool load_binary (std::istream& is, bool swap, 
-			      oct_mach_info::float_format fmt) {
-      return true;
-    }
-
-#if defined (HAVE_HDF5)
-    virtual bool
-      save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
-      return true;
-    }
-
-    virtual bool
-      load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
-      return true;
-    }
-#endif
-
-    virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const {
-      return string_value();
-    }
-
-    virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const {
-      return string_value();
-    }
-
-    static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret) {
-      // we assume that SWIG_op_prefix-prefixed functions are installed in global namespace
-      // (rather than any module namespace).
-
-      octave_function *fcn = is_valid_function(symbol, std::string(), false);
-      if (!fcn)
-	return false;
-      ret = fcn->do_multi_index_op(1, args)(0);
-      return true;
-    }
-
-    static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name) {
-      octave_swig_type *ost = Swig::swig_value_deref(x);
-      assert(ost);
-
-      octave_value ret;
-      if (ost->dispatch_unary_op(std::string("__") + op_name + std::string("__"), ret))
-	return ret;
-      std::string symbol = SWIG_op_prefix + ost->swig_type_name() + "_" + op_name;
-      octave_value_list args;
-      args.append(make_value_hack(x));
-      if (dispatch_global_op(symbol, args, ret))
-	return ret;
-
-      error("could not dispatch unary operator");
-      return octave_value();
-    }
-
-    static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name) {
-      octave_swig_type *lhs_ost = Swig::swig_value_deref(lhs);
-      octave_swig_type *rhs_ost = Swig::swig_value_deref(rhs);
-
-      octave_value ret;
-      if (lhs_ost && lhs_ost->dispatch_binary_op(std::string("__") + op_name + std::string("__"), rhs, ret))
-	return ret;
-      if (rhs_ost) {
-        if (strlen(op_name) == 2  && (op_name[1] == 't' || op_name[1] == 'e')) {
-          if (op_name[0] == 'l' && rhs_ost->dispatch_binary_op(std::string("__g") + op_name[1] + std::string("__"), lhs, ret))
-            return ret;
-          if (op_name[0] == 'g' && rhs_ost->dispatch_binary_op(std::string("__l") + op_name[1] + std::string("__"), lhs, ret))
-            return ret;
-        }
-        if (rhs_ost->dispatch_binary_op(std::string("__r") + op_name + std::string("__"), lhs, ret))
-          return ret;
-      }
-
-      std::string symbol;
-      octave_value_list args;
-      args.append(make_value_hack(lhs));
-      args.append(make_value_hack(rhs));
-
-      symbol = SWIG_op_prefix;
-      symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
-      symbol += "_";
-      symbol += op_name;
-      symbol += "_";
-      symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
-      if (dispatch_global_op(symbol, args, ret))
-	return ret;
-
-      symbol = SWIG_op_prefix;
-      symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
-      symbol += "_";
-      symbol += op_name;
-      symbol += "_";
-      symbol += "any";
-      if (dispatch_global_op(symbol, args, ret))
-	return ret;
-
-      symbol = SWIG_op_prefix;
-      symbol += "any";
-      symbol += "_";
-      symbol += op_name;
-      symbol += "_";
-      symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
-      if (dispatch_global_op(symbol, args, ret))
-	return ret;
-
-      error("could not dispatch binary operator");
-      return octave_value();
-    }
-
-    void print(std::ostream &os, bool pr_as_read_syntax = false) const {
-      if (is_string()) {
-	os << string_value();
-	return;
-      }
-
-      member_map tmp;
-      load_members(tmp);
-
-      indent(os);
-      os << "{"; newline(os);
-      increment_indent_level();
-      for (unsigned int j = 0; j < types.size(); ++j) {
-        indent(os);
-	if (types[j].first->clientdata) {
-	  const swig_octave_class *c = (const swig_octave_class *) types[j].first->clientdata;
-	  os << c->name << ", ptr = " << types[j].second.ptr; newline(os);
-	} else {
-	  os << types[j].first->name << ", ptr = " << types[j].second.ptr; newline(os);
-	}
-      }
-      for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
-        indent(os);
-	if (it->second.first) {
-	  const char *objtype = it->second.first->method ? "method" : "variable";
-	  const char *modifier = (it->second.first->flags &1) ? "static " : (it->second.first->flags &2) ? "global " : "";
-	  os << it->second.first->name << " (" << modifier << objtype << ")"; newline(os);
-	  assert(it->second.first->name == it->first);
-	} else {
-	  os << it->first; newline(os);
-	}
-      }
-      decrement_indent_level();
-      indent(os);
-      os << "}"; newline(os);
-    }
-  };
-
-  // Octave tries hard to preserve pass-by-value semantics. Eg, assignments
-  // will call clone() via make_unique() if there is more than one outstanding 
-  // reference to the lhs, and forces the clone's reference count to 1 
-  // (so you can't just increment your own count and return this).
-  //
-  // One way to fix this (without modifying Octave) is to add a level of
-  // indirection such that clone copies ref-counted pointer and we keep 
-  // pass-by-ref semantics (which are more natural/expected for C++ bindings).
-  //
-  // Supporting both pass-by-{ref,value} and toggling via %feature/option 
-  // might be nice.
-
-  class octave_swig_ref:public octave_base_value {
-    octave_swig_type *ptr;
-  public:
-    octave_swig_ref(octave_swig_type *_ptr = 0)
-      :ptr(_ptr) { }
-
-    ~octave_swig_ref()
-      { if (ptr) ptr->decref(); }
-
-    octave_swig_type *get_ptr() const
-      { return ptr; }
-
-    octave_base_value *clone() const
-      { if (ptr) ptr->incref(); return new octave_swig_ref(ptr); }
-
-    octave_base_value *empty_clone() const
-      { return new octave_swig_ref(0); }
-
-    dim_vector dims(void) const 
-      { return ptr->dims(); }
-
-    bool is_defined() const
-      { return ptr->is_defined(); }
-
-    virtual bool is_map() const 
-      { return ptr->is_map(); }
-
-    virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) 
-      { return ptr->subsref(ops, idx); }
-
-    virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout)
-      { return ptr->subsref(ops, idx, nargout); }
-
-    octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs)
-      { return ptr->subsasgn(ops, idx, rhs); }
-
-    virtual bool is_object() const 
-      { return ptr->is_object(); }
-
-    virtual bool is_string() const 
-      { return ptr->is_string(); }
-
-    virtual std::string string_value(bool force = false) const 
-      { return ptr->string_value(force); }
-
-#if OCTAVE_API_VERSION_NUMBER >= 40
-    virtual octave_map map_value() const
-      { return ptr->map_value(); }
-#else
-    virtual Octave_map map_value() const
-      { return ptr->map_value(); }
-#endif
-
-    virtual string_vector map_keys() const
-      { return ptr->map_keys(); }
-
-    virtual bool save_ascii (std::ostream& os)
-      { return ptr->save_ascii(os); }
-
-    virtual bool load_ascii (std::istream& is)
-      { return ptr->load_ascii(is); }
-
-    virtual bool save_binary (std::ostream& os, bool& save_as_floats)
-      { return ptr->save_binary(os, save_as_floats); }
-
-    virtual bool load_binary (std::istream& is, bool swap, 
-			      oct_mach_info::float_format fmt)
-      { return ptr->load_binary(is, swap, fmt); }
-
-#if defined (HAVE_HDF5)
-    virtual bool
-      save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats)
-      { return ptr->save_hdf5(loc_id, name, save_as_floats); }
-
-    virtual bool
-      load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug)
-      { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
-#endif
-
-    virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const
-      { return ptr->convert_to_str(pad, force, type); }
-
-    virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
-      { return ptr->convert_to_str_internal(pad, force, type); }
-
-    void print(std::ostream &os, bool pr_as_read_syntax = false) const
-      { return ptr->print(os, pr_as_read_syntax); }
-
-  private:
-    DECLARE_OCTAVE_ALLOCATOR;
-    DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA;
-  };
-  DEFINE_OCTAVE_ALLOCATOR(octave_swig_ref);
-  DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_ref, "swig_ref", "swig_ref");
-
-  class octave_swig_packed:public octave_base_value {
-    swig_type_info *type;
-    std::vector < char > buf;
-  public:
-
-    octave_swig_packed(swig_type_info *_type = 0, const void *_buf = 0, size_t _buf_len = 0)
-      :	type(_type), buf((const char*)_buf, (const char*)_buf + _buf_len) {
-    }
-
-    bool copy(swig_type_info *outtype, void *ptr, size_t sz) const {
-      if (outtype && outtype != type)
-	return false;
-      assert(sz <= buf.size());
-      std::copy(buf.begin(), buf.begin()+sz, (char*)ptr);
-      return true;
-    }
-
-    octave_base_value *clone() const {
-      return new octave_swig_packed(*this);
-    }
-
-    octave_base_value *empty_clone() const {
-      return new octave_swig_packed();
-    }
-
-    bool is_defined() const {
-      return true;
-    }
-
-    void print(std::ostream &os, bool pr_as_read_syntax = false) const {
-      indent(os);
-      os << "swig packed type: name = " << (type ? type->name : std::string()) << ", len = " << buf.size(); newline(os);
-    }
-
-
-    virtual bool save_ascii (std::ostream& os) {
-      return true;
-    }
-
-    virtual bool load_ascii (std::istream& is) {
-      return true;
-    }
-
-    virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
-      return true;
-    }
-
-    virtual bool load_binary (std::istream& is, bool swap, 
-			      oct_mach_info::float_format fmt) {
-      return true;
-    }
-
-#if defined (HAVE_HDF5)
-    virtual bool
-      save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
-      return true;
-    }
-
-    virtual bool
-      load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
-      return true;
-    }
-#endif
-
-  private:
-    DECLARE_OCTAVE_ALLOCATOR;
-    DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA;
-  };
-  DEFINE_OCTAVE_ALLOCATOR(octave_swig_packed);
-  DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_packed, "swig_packed", "swig_packed");
-
-  static octave_value_list octave_set_immutable(const octave_value_list &args, int nargout) {
-    error("attempt to set immutable member variable");
-    return octave_value_list();
-  }
-
-  struct octave_value_ref {
-    const octave_value_list &ovl;
-    int j;
-
-    octave_value_ref(const octave_value_list &_ovl, int _j)
-      :ovl(_ovl), j(_j) { }
-
-    operator  octave_value() const {
-      return ovl(j);
-    }
-
-    octave_value operator*() const {
-      return ovl(j);
-    }
-  };
-
-
-namespace Swig {
-
-  SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost) {
-    return new octave_swig_ref(ost);
-  }
-
-  SWIGRUNTIME octave_swig_type *swig_value_deref(octave_value ov) {
-    if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
-      ov = ov.cell_value()(0);
-    return swig_value_deref(*ov.internal_rep());
-  }
-
-  SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov) {
-    if (ov.type_id() != octave_swig_ref::static_type_id())
-      return 0;
-    const octave_swig_ref *osr = static_cast < const octave_swig_ref *>(&ov);
-    return osr->get_ptr();
-  }
-
-}
-
-
-#define swig_unary_op(name) \
-SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
-  return octave_swig_type::dispatch_unary_op(x,#name); \
-}
-#define swig_binary_op(name) \
-SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
-  return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
-}
-#define swigreg_unary_op(name) \
-if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
-octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
-#define swigreg_binary_op(name) \
-if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
-octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
-
-  swig_unary_op(not);
-  swig_unary_op(uplus);
-  swig_unary_op(uminus);
-  swig_unary_op(transpose);
-  swig_unary_op(hermitian);
-  swig_unary_op(incr);
-  swig_unary_op(decr);
-
-  swig_binary_op(add);
-  swig_binary_op(sub);
-  swig_binary_op(mul);
-  swig_binary_op(div);
-  swig_binary_op(pow);
-  swig_binary_op(ldiv);
-  swig_binary_op(lshift);
-  swig_binary_op(rshift);
-  swig_binary_op(lt);
-  swig_binary_op(le);
-  swig_binary_op(eq);
-  swig_binary_op(ge);
-  swig_binary_op(gt);
-  swig_binary_op(ne);
-  swig_binary_op(el_mul);
-  swig_binary_op(el_div);
-  swig_binary_op(el_pow);
-  swig_binary_op(el_ldiv);
-  swig_binary_op(el_and);
-  swig_binary_op(el_or);
-
-  SWIGRUNTIME void SWIG_InstallUnaryOps(int tid) {
-    swigreg_unary_op(not);
-    swigreg_unary_op(uplus);
-    swigreg_unary_op(uminus);
-    swigreg_unary_op(transpose);
-    swigreg_unary_op(hermitian);
-    swigreg_unary_op(incr);
-    swigreg_unary_op(decr);
-  }
-  SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2) {
-    swigreg_binary_op(add);
-    swigreg_binary_op(sub);
-    swigreg_binary_op(mul);
-    swigreg_binary_op(div);
-    swigreg_binary_op(pow);
-    swigreg_binary_op(ldiv);
-    swigreg_binary_op(lshift);
-    swigreg_binary_op(rshift);
-    swigreg_binary_op(lt);
-    swigreg_binary_op(le);
-    swigreg_binary_op(eq);
-    swigreg_binary_op(ge);
-    swigreg_binary_op(gt);
-    swigreg_binary_op(ne);
-    swigreg_binary_op(el_mul);
-    swigreg_binary_op(el_div);
-    swigreg_binary_op(el_pow);
-    swigreg_binary_op(el_ldiv);
-    swigreg_binary_op(el_and);
-    swigreg_binary_op(el_or);
-  }
-  SWIGRUNTIME void SWIG_InstallOps(int tid) {
-    // here we assume that tid are conseq integers increasing from zero, and 
-    // that our tid is the last one. might be better to have explicit string 
-    // list of types we should bind to, and use lookup_type to resolve their tid.
-
-    SWIG_InstallUnaryOps(tid);
-    SWIG_InstallBinaryOps(tid, tid);
-    for (int j = 0; j < tid; ++j) {
-      SWIG_InstallBinaryOps(j, tid);
-      SWIG_InstallBinaryOps(tid, j);
-    }
-  }
-
-SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
-  int own = (flags &SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
-
-#ifdef SWIG_DIRECTORS
-  Swig::Director *d = Swig::get_rtdir(ptr);
-  if (d && Swig::swig_director_get_self(d))
-    return Swig::swig_director_get_self(d)->as_value();
-#endif
-  return Swig::swig_value_ref(new octave_swig_type(ptr, type, own));
-}
-
-SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own) {
-  if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
-    ov = ov.cell_value()(0);
-  if (!ov.is_defined() ||
-      (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
-    if (ptr)
-      *ptr = 0;
-    return SWIG_OK;
-  }
-  if (ov.type_id() != octave_swig_ref::static_type_id())
-    return SWIG_ERROR;
-  octave_swig_ref *osr = static_cast < octave_swig_ref *>(ov.internal_rep());
-  octave_swig_type *ost = osr->get_ptr();
-  void *vptr = ost->cast(type, own, flags);
-  if (!vptr)
-    return SWIG_ERROR;
-  if (ptr)
-    *ptr = vptr;
-  return SWIG_OK;
-}
-
-SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
-  return new octave_swig_packed(type, (char *) ptr, sz);
-}
-
-SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type) {
-  if (!ov.is_defined())
-    return SWIG_ERROR;
-  if (ov.type_id() != octave_swig_packed::static_type_id())
-    return SWIG_ERROR;
-  octave_swig_packed *ost = static_cast < octave_swig_packed *>(ov.internal_rep());
-  return ost->copy(type, (char *) ptr, sz) ? SWIG_OK : SWIG_ERROR;
-}
-
-SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov) {
-  module_ns->assign(name, ov);
-}
-
-SWIGRUNTIMEINLINE octave_value SWIG_Octave_GetGlobalValue(std::string name) {
-  return get_global_value(name, true);
-}
-
-SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value& value) {
-  set_global_value(name, value);
-}
-
-SWIGRUNTIME void SWIG_Octave_LinkGlobalValue(std::string name) {
-#if OCTAVE_API_VERSION_NUMBER < 37
-  link_to_global_variable(curr_sym_tab->lookup(name, true));
-#else
-  symbol_table::varref(name);
-  symbol_table::mark_global(name);
-#endif
-}
-
-SWIGRUNTIME swig_module_info *SWIG_Octave_GetModule(void *clientdata) {
-  octave_value ov = SWIG_Octave_GetGlobalValue("__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION);
-  if (!ov.is_defined() ||
-      ov.type_id() != octave_swig_packed::static_type_id())
-    return 0;
-  const octave_swig_packed* osp = 
-    static_cast < const octave_swig_packed *> (ov.internal_rep());
-  swig_module_info *pointer = 0;
-  osp->copy(0, &pointer, sizeof(swig_module_info *));
-  return pointer;
-}
-
-SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer) {
-  octave_value ov = new octave_swig_packed(0, &pointer, sizeof(swig_module_info *));
-  SWIG_Octave_SetGlobalValue("__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION, ov);
-}
diff --git a/share/swig/2.0.11/octave/octruntime.swg b/share/swig/2.0.11/octave/octruntime.swg
deleted file mode 100644
index 43313c3..0000000
--- a/share/swig/2.0.11/octave/octruntime.swg
+++ /dev/null
@@ -1,323 +0,0 @@
-%insert(runtime) %{
-#include <cstdlib>
-#include <iostream>
-#include <octave/oct.h>
-#include <octave/Cell.h>
-#include <octave/dynamic-ld.h>
-#include <octave/oct-env.h>
-#include <octave/oct-map.h>
-#include <octave/ov-fcn-handle.h>
-#include <octave/parse.h>
-#include <octave/toplev.h>
-#include <octave/unwind-prot.h>
-%}
-
-%insert(runtime) "swigrun.swg";
-%insert(runtime) "swigerrors.swg";
-%insert(runtime) "octrun.swg";
-
-%insert(initbeforefunc) "swiginit.swg"
-
-%insert(initbeforefunc) %{
-
-static bool SWIG_init_user(octave_swig_type* module_ns);
-
-SWIGINTERN bool SWIG_Octave_LoadModule(std::string name) {
-  bool retn;
-  {
-#if OCTAVE_API_VERSION_NUMBER < 38
-    unwind_protect::begin_frame("SWIG_Octave_LoadModule");
-    unwind_protect_int(error_state);
-    unwind_protect_int(warning_state);
-    unwind_protect_bool(discard_error_messages);
-    unwind_protect_bool(discard_warning_messages);
-#else
-    unwind_protect frame;
-    frame.protect_var(error_state);
-    frame.protect_var(warning_state);
-    frame.protect_var(discard_error_messages);
-    frame.protect_var(discard_warning_messages);
-#endif
-    error_state = 0;
-    warning_state = 0;
-    discard_error_messages = true;
-    discard_warning_messages = true;
-    feval(name, octave_value_list(), 0);
-    retn = (error_state == 0);
-#if OCTAVE_API_VERSION_NUMBER < 38
-    unwind_protect::run_frame("SWIG_Octave_LoadModule");
-#endif
-  }
-  if (!retn) {
-    error(SWIG_name_d ": could not load module `%s'", name.c_str());
-  }
-  return retn;
-}
-
-SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name) {
-  bool retn;
-  {
-#if OCTAVE_API_VERSION_NUMBER < 38
-    unwind_protect::begin_frame("SWIG_Octave_InstallFunction");
-    unwind_protect_int(error_state);
-    unwind_protect_int(warning_state);
-    unwind_protect_bool(discard_error_messages);
-    unwind_protect_bool(discard_warning_messages);
-#else
-    unwind_protect frame;
-    frame.protect_var(error_state);
-    frame.protect_var(warning_state);
-    frame.protect_var(discard_error_messages);
-    frame.protect_var(discard_warning_messages);
-#endif
-    error_state = 0;
-    warning_state = 0;
-    discard_error_messages = true;
-    discard_warning_messages = true;
-    octave_value_list args;
-    args.append(name);
-    args.append(octloadfcn->fcn_file_name());
-    error_state = 0;
-    feval("autoload", args, 0);
-    retn = (error_state == 0);
-#if OCTAVE_API_VERSION_NUMBER < 38
-    unwind_protect::run_frame("SWIG_Octave_InstallFunction");
-#endif
-  }
-  if (!retn) {
-    error(SWIG_name_d ": could not load function `%s'", name.c_str());
-  }
-  return retn;
-}
-
-static const char *const subclass_usage = "-*- texinfo -*- \n\
-@deftypefn {Loadable Function} {} subclass()\n\
-@deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
-Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
-\n\
-See the SWIG manual for usage examples.\n\
-@end deftypefn";
-
-DEFUN_DLD( subclass, args, nargout, subclass_usage ) {
-  octave_swig_type *top = new octave_swig_type;
-  for (int j = 0; j < args.length(); ++j) {
-    if (args(j).type_id() == octave_swig_ref::static_type_id()) {
-      octave_swig_ref *osr = static_cast < octave_swig_ref *>(args(j).internal_rep());
-      octave_swig_type *ost = osr->get_ptr();
-      if (!ost->is_owned()) {
-        error("subclass: cannot subclass object not constructed on octave side");
-        return octave_value_list();
-      }
-      top->merge(*ost);
-    } else if (args(j).is_function_handle()) {
-      top->assign(args(j).fcn_handle_value()->fcn_name(), args(j));
-    } else if (args(j).is_string()) {
-      if (j + 1 >= args.length()) {
-        error("subclass: member assignments must be of string,value form");
-        return octave_value_list();
-      }
-      top->assign(args(j).string_value(), args(j + 1));
-      ++j;
-    } else {
-      error("subclass: invalid arguments to subclass()");
-      return octave_value_list();
-    }
-  }
-  return octave_value(Swig::swig_value_ref(top));
-}
-
-static const char *const swig_type_usage = "-*- texinfo -*- \n\
-@deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
-Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
-@end deftypefn";
-
-DEFUN_DLD( swig_type, args, nargout, swig_type_usage ) {
-  if (args.length() != 1) {
-    error("swig_type: must be called with only a single object");
-    return octave_value_list();
-  }
-  octave_swig_type *ost = Swig::swig_value_deref(args(0));
-  if (!ost) {
-    error("swig_type: object is not a swig_ref");
-    return octave_value_list();
-  }
-  return octave_value(ost->swig_type_name());
-}
-
-static const char *const swig_typequery_usage = "-*- texinfo -*- \n\
-@deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
-Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
-otherwise return `<unknown>'.\n\
-@end deftypefn";
-
-DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
-  if (args.length() != 1 || !args(0).is_string()) {
-    error("swig_typequery: must be called with single string argument");
-    return octave_value_list();
-  }
-  swig_module_info *module = SWIG_GetModule(0);
-  swig_type_info *type = SWIG_TypeQueryModule(module, module, args(0).string_value().c_str());
-  if (!type)
-    return octave_value("<unknown>");
-  return octave_value(type->name);
-}
-
-static const char *const swig_this_usage = "-*- texinfo -*- \n\
-@deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
-Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
-@end deftypefn";
-
-DEFUN_DLD( swig_this, args, nargout, swig_this_usage ) {
-  if (args.length() != 1) {
-    error("swig_this: must be called with only a single object");
-    return octave_value_list();
-  }
-  if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
-    return octave_value(octave_uint64(0));
-  octave_swig_type *ost = Swig::swig_value_deref(args(0));
-  if (!ost) {
-    error("swig_this: object is not a swig_ref");
-    return octave_value_list();
-  }
-  return octave_value(octave_uint64((unsigned long long) ost->swig_this()));
-}
-
-static const char *const SWIG_name_usage = "-*- texinfo -*- \n\
-@deftypefn {Loadable Module} {} " SWIG_name_d "\n\
-Loads the SWIG-generated module `" SWIG_name_d "'.\n\
-@end deftypefn";
-
-DEFUN_DLD( SWIG_name, args, nargout, SWIG_name_usage ) {
-
-  static octave_swig_type* module_ns = 0;
-
-  // workaround to prevent octave seg-faulting on exit: set Octave exit function
-  // octave_exit to _Exit, which exits immediately without trying to cleanup memory.
-  // definitely affects version 3.2.*, not sure about 3.3.*, seems to be fixed in
-  // version 3.4.* and above. can be turned off with macro definition.
-#ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
-#if 36 < OCTAVE_API_VERSION_NUMBER && OCTAVE_API_VERSION_NUMBER < 45
-  octave_exit = ::_Exit;
-#endif
-#endif
-
-  // check for no input and output args
-  if (args.length() != 0 || nargout != 0) {
-    print_usage();
-    return octave_value_list();
-  }
-
-  // create module on first function call
-  if (!module_ns) {
-
-    // workaround bug in octave where installing global variable of custom type and then
-    // exiting without explicitly clearing the variable causes octave to segfault.
-#if OCTAVE_API_VERSION_NUMBER > 36
-    octave_value_list eval_args;
-    eval_args.append("base");
-    eval_args.append("function __swig_atexit__; "
-                     "  if mislocked() "
-                     "    clear -all; "
-                     "  else "
-                     "    mlock(); "
-                     "  endif; "
-                     "endfunction; "
-                     "__swig_atexit__; "
-                     "atexit(\"__swig_atexit__\", false); "
-                     "atexit(\"__swig_atexit__\")");
-    feval("evalin", eval_args, 0);
-#endif
-
-    octave_swig_ref::register_type();
-    octave_swig_packed::register_type();
-    SWIG_InitializeModule(0);
-    SWIG_PropagateClientData();
-
-    octave_function *me = octave_call_stack::current();
-
-    if (!SWIG_Octave_InstallFunction(me, "swig_type")) {
-      return octave_value_list();
-    }
-    if (!SWIG_Octave_InstallFunction(me, "swig_typequery")) {
-      return octave_value_list();
-    }
-    if (!SWIG_Octave_InstallFunction(me, "swig_this")) {
-      return octave_value_list();
-    }
-    if (!SWIG_Octave_InstallFunction(me, "subclass")) {
-      return octave_value_list();
-    }
-
-    octave_swig_type* cvar_ns=0;
-    if (std::string(SWIG_global_name) != ".") {
-      cvar_ns=new octave_swig_type;
-      for (int j=0;swig_globals[j].name;++j)
-        if (swig_globals[j].get_method)
-          cvar_ns->assign(swig_globals[j].name,&swig_globals[j]);
-    }
-
-    module_ns=new octave_swig_type(0, 0, 0, true);
-    if (std::string(SWIG_global_name) != ".") {
-      module_ns->assign(SWIG_global_name,Swig::swig_value_ref(cvar_ns));
-    }
-    else {
-      for (int j=0;swig_globals[j].name;++j)
-        if (swig_globals[j].get_method)
-          module_ns->assign(swig_globals[j].name,&swig_globals[j]);
-    }
-    for (int j=0;swig_globals[j].name;++j)
-      if (swig_globals[j].method)
-        module_ns->assign(swig_globals[j].name,&swig_globals[j]);
-
-    // * need better solution here; swig_type -> octave_class mapping is
-    // * really n-to-1, in some cases such as template partial spec, etc.
-    // * see failing tests.
-    for (int j=0;swig_types[j];++j)
-      if (swig_types[j]->clientdata) {
-        swig_octave_class* c=(swig_octave_class*)swig_types[j]->clientdata;
-        module_ns->assign(c->name,
-                        Swig::swig_value_ref
-                        (new octave_swig_type(0,swig_types[j])));
-      }
-
-    if (!SWIG_init_user(module_ns)) {
-      delete module_ns;
-      module_ns=0;
-      return octave_value_list();
-    }
-
-    SWIG_InstallOps(octave_swig_ref::static_type_id());
-
-    octave_swig_type::swig_member_const_iterator mb;
-    for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
-      if (mb->second.first && mb->second.first->method) {
-        if (!SWIG_Octave_InstallFunction(me, mb->first)) {
-          return octave_value_list();
-        }
-      }
-    }
-
-#if OCTAVE_API_VERSION_NUMBER < 37
-    mlock(me->name());
-#else
-    mlock();
-#endif
-
-  }
-
-  octave_swig_type::swig_member_const_iterator mb;
-  for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
-    if (mb->second.second.is_defined()) {
-      SWIG_Octave_SetGlobalValue(mb->first, mb->second.second);
-      SWIG_Octave_LinkGlobalValue(mb->first);
-    }
-  }
-
-  SWIG_Octave_SetGlobalValue(SWIG_name_d, module_ns->as_value());
-  SWIG_Octave_LinkGlobalValue(SWIG_name_d);
-
-  return octave_value_list();
-
-}
-
-%}
diff --git a/share/swig/2.0.11/octave/octstdcommon.swg b/share/swig/2.0.11/octave/octstdcommon.swg
deleted file mode 100644
index 96923f4..0000000
--- a/share/swig/2.0.11/octave/octstdcommon.swg
+++ /dev/null
@@ -1,226 +0,0 @@
-%fragment("StdTraits","header",fragment="StdTraitsCommon")
-{
-namespace swig {  
-// Traits that provides the from method
-  template <class Type> struct traits_from_ptr {
-    static octave_value from(Type *val, int owner = 0) {
-      return SWIG_NewPointerObj(val, type_info<Type>(), owner);
-    }
-  };
-
-  template <class Type> struct traits_from {
-    static octave_value from(const Type& val) {
-      return traits_from_ptr<Type>::from(new Type(val), 1);
-    }
-  };
-
-  template <class Type> struct traits_from<Type *> {
-    static octave_value from(Type* val) {
-      return traits_from_ptr<Type>::from(val, 0);
-    }
-  };
-
-  template <class Type> struct traits_from<const Type *> {
-    static octave_value from(const Type* val) {
-      return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
-    }
-  };
-
-
-  template <class Type>
-  inline octave_value from(const Type& val) {
-    return traits_from<Type>::from(val);
-  }
-
-  template <class Type>
-  inline octave_value from_ptr(Type* val, int owner) {
-    return traits_from_ptr<Type>::from(val, owner);
-  }
-
-    // Traits that provides the asval/as/check method
-  template <class Type>
-  struct traits_asptr {   
-    static int asptr(const octave_value& obj, Type **val) {
-      Type *p;
-      int res = SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0);
-      if (SWIG_IsOK(res)) {
-	if (val) *val = p;
-      }
-      return res;
-    }
-  }; 
-
-  template <class Type>
-  inline int asptr(const octave_value& obj, Type **vptr) {
-    return traits_asptr<Type>::asptr(obj, vptr);
-  }
-
-  template <class Type> 
-  struct traits_asval {
-    static int asval(const octave_value& obj, Type *val) {
-      if (val) {
-	Type *p = 0;
-	int res = traits_asptr<Type>::asptr(obj, &p);
-	if (!SWIG_IsOK(res)) return res;	
-	if (p) {
-	  typedef typename noconst_traits<Type>::noconst_type noconst_type;
-	  *(const_cast<noconst_type*>(val)) = *p;
-	  if (SWIG_IsNewObj(res)){
-	    %delete(p);
-	    res = SWIG_DelNewMask(res);
-	  }
-	  return res;
-	} else {
-	  return SWIG_ERROR;
-	}
-      } else {
-	return traits_asptr<Type>::asptr(obj, (Type **)(0));
-      }
-    }
-  };
-
-  template <class Type> struct traits_asval<Type*> {
-    static int asval(const octave_value& obj, Type **val) {
-      if (val) {
-        typedef typename noconst_traits<Type>::noconst_type noconst_type;
-        noconst_type *p = 0;
-        int res = traits_asptr<noconst_type>::asptr(obj,  &p);
-        if (SWIG_IsOK(res)) {
-          *(const_cast<noconst_type**>(val)) = p;
-	}
-	return res;
-      } else {
-	return traits_asptr<Type>::asptr(obj, (Type **)(0));
-      }
-    }
-  };
-  
-  template <class Type>
-  inline int asval(const octave_value& obj, Type *val) {
-    return traits_asval<Type>::asval(obj, val);
-  }
-
-  template <class Type> 
-  struct traits_as<Type, value_category> {
-    static Type as(const octave_value& obj, bool throw_error) {
-      Type v;
-      int res = asval(obj, &v);
-      if (!obj.is_defined() || !SWIG_IsOK(res)) {
-	if (!Octave_Error_Occurred()) {
-	  %type_error(swig::type_name<Type>());
-	}
-	if (throw_error) throw std::invalid_argument("bad type");
-      }
-      return v;
-    }
-  };
-
-  template <class Type> 
-  struct traits_as<Type, pointer_category> {
-    static Type as(const octave_value& obj, bool throw_error) {
-      Type *v = 0;      
-      int res = traits_asptr<Type>::asptr(obj, &v);
-      if (SWIG_IsOK(res) && v) {
-	if (SWIG_IsNewObj(res)) {
-	  Type r(*v);
-	  %delete(v);
-	  return r;
-	} else {
-	  return *v;
-	}
-      } else {
-	// Uninitialized return value, no Type() constructor required.
-	static Type *v_def = (Type*) malloc(sizeof(Type));
-	if (!Octave_Error_Occurred()) {
-	  %type_error(swig::type_name<Type>());
-	}
-	if (throw_error) throw std::invalid_argument("bad type");
-	memset(v_def,0,sizeof(Type));
-	return *v_def;
-      }
-    }
-  };
-
-  template <class Type> 
-  struct traits_as<Type*, pointer_category> {
-    static Type* as(const octave_value& obj, bool throw_error) {
-      Type *v = 0;      
-      int res = traits_asptr<Type>::asptr(obj, &v);
-      if (SWIG_IsOK(res)) {
-	return v;
-      } else {
-	if (!Octave_Error_Occurred()) {
-	  %type_error(swig::type_name<Type>());
-	}
-	if (throw_error) throw std::invalid_argument("bad type");
-	return 0;
-      }
-    }
-  };
-    
-  template <class Type>
-  inline Type as(const octave_value& obj, bool te = false) {
-    return traits_as<Type, typename traits<Type>::category>::as(obj, te);
-  }
-
-  template <class Type> 
-  struct traits_check<Type, value_category> {
-    static bool check(const octave_value& obj) {
-      int res = asval(obj, (Type *)(0));
-      return SWIG_IsOK(res) ? true : false;
-    }
-  };
-
-  template <class Type> 
-  struct traits_check<Type, pointer_category> {
-    static bool check(const octave_value& obj) {
-      int res = asptr(obj, (Type **)(0));
-      return SWIG_IsOK(res) ? true : false;
-    }
-  };
-
-  template <class Type>
-  inline bool check(const octave_value& obj) {
-    return traits_check<Type, typename traits<Type>::category>::check(obj);
-  }
-}
-}
-
-%define %specialize_std_container(Type,Check,As,From)
-%{
-namespace swig {
-  template <>  struct traits_asval<Type > {   
-    typedef Type value_type;
-    static int asval(const octave_value& obj, value_type *val) {
-      if (Check(obj)) {
-	if (val) *val = As(obj);
-	return SWIG_OK;
-      }
-      return SWIG_ERROR;
-    }
-  };
-  template <>  struct traits_from<Type > {
-    typedef Type value_type;
-    static octave_value from(const value_type& val) {
-      return From(val);
-    }
-  };
-
-  template <> 
-  struct traits_check<Type, value_category> {
-    static int check(const octave_value& obj) {
-      int res = Check(obj);
-      return obj && res ? res : 0;
-    }
-  };
-}
-%}
-%enddef
-
-
-#define specialize_std_vector(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
-#define specialize_std_list(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
-#define specialize_std_deque(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
-#define specialize_std_set(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
-#define specialize_std_multiset(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
-
diff --git a/share/swig/2.0.11/octave/octtypemaps.swg b/share/swig/2.0.11/octave/octtypemaps.swg
deleted file mode 100644
index e331cf4..0000000
--- a/share/swig/2.0.11/octave/octtypemaps.swg
+++ /dev/null
@@ -1,92 +0,0 @@
-
-// Include fundamental fragemt definitions
-%include <typemaps/fragments.swg>
-
-// Look for user fragments file.
-%include <octfragments.swg>
-
-// Octave fragments for primitive types
-%include <octprimtypes.swg>
-
-// Octave fragments for char* strings
-//%include <octstrings.swg>
-
-
-#ifndef SWIG_DIRECTOR_TYPEMAPS
-#define SWIG_DIRECTOR_TYPEMAPS
-#endif
-
-// Octave types
-#define SWIG_Object                      octave_value
-#define VOID_Object                      octave_value()
-
-/*
-// Octave allows implicit conversion
-#define %implicitconv_flag              $implicitconv 
-*/
-
-// append output
-#define SWIG_AppendOutput(result, obj)  SWIG_Octave_AppendOutput(result, obj)
-
-// set constant
-#define SWIG_SetConstant(name, obj)     SWIG_Octave_SetConstant(module_ns,name,obj) 
-
-// raise
-#define SWIG_Octave_Raise(OBJ, TYPE, DESC) error("C++ side threw an exception of type " TYPE)
-#define SWIG_Raise(obj, type, desc)     SWIG_Octave_Raise(obj, type, desc)
-
-// Include the unified typemap library
-%include <typemaps/swigtypemaps.swg>
-
-%typecheck(SWIG_TYPECHECK_SWIGOBJECT) SWIG_Object "$1 = (*$input).is_defined();";
-%typecheck(SWIG_TYPECHECK_SWIGOBJECT) octave_value_list "$1 = true;";
-
-%typemap(in) (octave_value_list varargs,...) {
-  for (int j=$argnum-1;j<args.length();++j)
-    $1.append(args(j));
-}
-%typecheck(2000) (octave_value_list varargs,...) {
-  $1=1;
-}
-
-%typemap(in) (const octave_value_list& varargs,...) (octave_value_list tmp) {
-  for (int j=$argnum-1;j<args.length();++j)
-    tmp.append(args(j));
-  $1=&tmp;
-}
-%typecheck(2000) (const octave_value_list& varargs,...) {
-  $1=1;
-}
-
-%typemap(out) octave_value_list {
-  _outp->append($1);
-}
-%typemap(out,noblock=1) octave_map, Octave_map {
-  $result=$1;
-}
-%typemap(out,noblock=1) NDArray {
-  $result=$1;
-}
-%typemap(out,noblock=1) Cell {
-  $result=$1;
-}
-
-/*
-// Smart Pointers
-%typemap(out,noblock=1) const SWIGTYPE & SMARTPOINTER  {
-  $result = SWIG_NewPointerObj(%new_copy(*$1, $*ltype), $descriptor, SWIG_POINTER_OWN | %newpointer_flags);
-}
-
-%typemap(ret) const SWIGTYPE & SMARTPOINTER, SWIGTYPE SMARTPOINTER {
-  octave_swig_type* lobj=Swig::swig_value_deref($result);
-  if (lobj) {
-    std::list<octave_value_list> idx;
-    idx.push_back(octave_value("__deref__"));
-    idx.push_back(octave_value_list());
-    octave_value_list ovl(lobj->subsref(".(",idx));
-    octave_swig_type* robj=ovl.length()>=1?Swig::swig_value_deref(ovl(0)):0;
-    if (robj && !error_state)
-      lobj->append(robj);
-  }
-}
-*/
diff --git a/share/swig/2.0.11/octave/std_carray.i b/share/swig/2.0.11/octave/std_carray.i
deleted file mode 100644
index 9e2338a..0000000
--- a/share/swig/2.0.11/octave/std_carray.i
+++ /dev/null
@@ -1,56 +0,0 @@
-%include <pycontainer.swg>
-
-/*
-%fragment("StdCarrayTraits","header",fragment="StdSequenceTraits")
-{
-namespace swig {
-  template <class T, size_t S>
-  struct traits_asptr<std::carray<T, S> >  {
-    static int asptr(PyObject *obj, std::carray<T, S> **array) {
-      return traits_asptr_stdseq<std::carray<T, S> >::asptr(obj, array);
-    }
-  };
-}
-}
-
-%warnfilter(SWIGWARN_IGNORE_OPERATOR_INDEX) std::carray::operator[];
-
-%extend std::carray {
-  %fragment(SWIG_Traits_frag(std::carray<_Type, _Size >), "header",
-	    fragment="SwigPyIterator_T",
-	    fragment=SWIG_Traits_frag(_Type),
-	    fragment="StdCarrayTraits") {
-    namespace swig {
-      template <>  struct traits<std::carray<_Type, _Size > > {
-	typedef pointer_category category;
-	static const char* type_name() {
-	  return "std::carray<" #_Type "," #_Size " >";
-	}
-      };
-    }
-  }
-  
-  %typemaps_asptr(SWIG_TYPECHECK_VECTOR, swig::asptr,
-		  SWIG_Traits_frag(std::carray<_Type, _Size >),
-		  std::carray<_Type, _Size >);
-
-  %typemap(out,noblock=1) iterator, const_iterator {
-    $result = SWIG_NewPointerObj(swig::make_output_iterator((const $type &)$1),
-				 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
-  }
-  
-  inline size_t __len__() const { return self->size(); }
-  
-  inline const _Type& __getitem__(size_t i) const { return (*self)[i]; }
-  
-  inline void __setitem__(size_t i, const _Type& v) { (*self)[i] = v; }
-
-  
-  swig::SwigPyIterator* __iter__(PyObject **PYTHON_SELF) {
-    return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
-  }
-}
-
-%include <std/std_carray.swg>
-*/
-
diff --git a/share/swig/2.0.11/octave/std_common.i b/share/swig/2.0.11/octave/std_common.i
deleted file mode 100644
index 9aebf7f..0000000
--- a/share/swig/2.0.11/octave/std_common.i
+++ /dev/null
@@ -1,72 +0,0 @@
-%include <std/std_except.i>
-%include <octstdcommon.swg>
-
-
-// Generate the traits for a 'primitive' type, such as 'double',
-// for which the SWIG_AsVal and SWIG_From methods are already defined.
-
-%define %traits_ptypen(Type...)
-  %fragment(SWIG_Traits_frag(Type),"header",
-	    fragment=SWIG_AsVal_frag(Type),
-	    fragment=SWIG_From_frag(Type),
-	    fragment="StdTraits") {
-namespace swig {
-  template <> struct traits<Type > {
-    typedef value_category category;
-    static const char* type_name() { return  #Type; }
-  };  
-  template <>  struct traits_asval<Type > {   
-    typedef Type value_type;
-    static int asval(octave_value obj, value_type *val) { 
-      return SWIG_AsVal(Type)(obj, val);
-    }
-  };
-  template <>  struct traits_from<Type > {
-    typedef Type value_type;
-    static octave_value from(const value_type& val) {
-      return SWIG_From(Type)(val);
-    }
-  };
-}
-}
-%enddef
-
-/* Traits for enums. This is bit of a sneaky trick needed because a generic template specialization of enums
-   is not possible (unless using template meta-programming which SWIG doesn't support because of the explicit
-   instantiations required using %template). The STL containers define the 'front' method and the typemap
-   below is used whenever the front method is wrapped returning an enum. This typemap simply picks up the
-   standard enum typemap, but additionally drags in a fragment containing the traits_asval and traits_from
-   required in the generated code for enums. */
-
-%define %traits_enum(Type...)
-  %fragment("SWIG_Traits_enum_"{Type},"header",
-	    fragment=SWIG_AsVal_frag(int),
-	    fragment=SWIG_From_frag(int),
-	    fragment="StdTraits") {
-namespace swig {
-  template <>  struct traits_asval<Type > {   
-    typedef Type value_type;
-    static int asval(octave_value obj, value_type *val) { 
-      return SWIG_AsVal(int)(obj, (int *)val);
-    }
-  };
-  template <>  struct traits_from<Type > {
-    typedef Type value_type;
-    static octave_value from(const value_type& val) {
-      return SWIG_From(int)((int)val);
-    }
-  };
-}
-}
-%typemap(out, fragment="SWIG_Traits_enum_"{Type}) const enum SWIGTYPE& front %{$typemap(out, const enum SWIGTYPE&)%}
-%enddef
-
-
-%include <std/std_common.i>
-
-//
-// Generates the traits for all the known primitive
-// C++ types (int, double, ...)
-//
-%apply_cpptypes(%traits_ptypen);
-
diff --git a/share/swig/2.0.11/octave/std_map.i b/share/swig/2.0.11/octave/std_map.i
deleted file mode 100644
index 7b85a54..0000000
--- a/share/swig/2.0.11/octave/std_map.i
+++ /dev/null
@@ -1,156 +0,0 @@
-// Maps
-
-%include <octcontainer.swg>
-
-%fragment("StdMapCommonTraits","header",fragment="StdSequenceTraits")
-{
-  namespace swig {
-    template <class ValueType>
-    struct from_key_oper 
-    {
-      typedef const ValueType& argument_type;
-      typedef octave_value result_type;
-      result_type operator()(argument_type v) const
-      {
-	return swig::from(v.first);
-      }
-    };
-
-    template <class ValueType>
-    struct from_value_oper 
-    {
-      typedef const ValueType& argument_type;
-      typedef octave_value result_type;
-      result_type operator()(argument_type v) const
-      {
-	return swig::from(v.second);
-      }
-    };
-
-    template<class OutIterator, class FromOper, class ValueType = typename OutIterator::value_type>
-    struct OctMapIterator_T : OctSwigIteratorClosed_T<OutIterator, ValueType, FromOper>
-    {
-      OctMapIterator_T(OutIterator curr, OutIterator first, OutIterator last, octave_value seq)
-	: OctSwigIteratorClosed_T<OutIterator,ValueType,FromOper>(curr, first, last, seq)
-      {
-      }
-    };
-
-
-    template<class OutIterator,
-	     class FromOper = from_key_oper<typename OutIterator::value_type> >
-    struct OctMapKeyIterator_T : OctMapIterator_T<OutIterator, FromOper>
-    {
-      OctMapKeyIterator_T(OutIterator curr, OutIterator first, OutIterator last, octave_value seq)
-	: OctMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
-      {
-      }
-    };
-
-    template<typename OutIter>
-    inline OctSwigIterator*
-    make_output_key_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, octave_value seq = octave_value())
-    {
-      return new OctMapKeyIterator_T<OutIter>(current, begin, end, seq);
-    }
-
-    template<class OutIterator,
-	     class FromOper = from_value_oper<typename OutIterator::value_type> >
-    struct OctMapValueIterator_T : OctMapIterator_T<OutIterator, FromOper>
-    {
-      OctMapValueIterator_T(OutIterator curr, OutIterator first, OutIterator last, octave_value seq)
-	: OctMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
-      {
-      }
-    };
-    
-
-    template<typename OutIter>
-    inline OctSwigIterator*
-    make_output_value_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, octave_value seq = 0)
-    {
-      return new OctMapValueIterator_T<OutIter>(current, begin, end, seq);
-    }
-  }
-}
-
-%fragment("StdMapTraits","header",fragment="StdMapCommonTraits")
-{
-  namespace swig {
-    template <class OctSeq, class K, class T >
-    inline void
-    assign(const OctSeq& octseq, std::map<K,T > *map) {
-      typedef typename std::map<K,T>::value_type value_type;
-      typename OctSeq::const_iterator it = octseq.begin();
-      for (;it != octseq.end(); ++it) {
-	map->insert(value_type(it->first, it->second));
-      }
-    }
-
-    template <class K, class T>
-    struct traits_asptr<std::map<K,T> >  {
-      typedef std::map<K,T> map_type;
-      static int asptr(octave_value obj, map_type **val) {
-	/*
-	int res = SWIG_ERROR;
-	if (PyDict_Check(obj)) {
-	  SwigVar_PyObject items = PyObject_CallMethod(obj,(char *)"items",NULL);
-	  res = traits_asptr_stdseq<std::map<K,T>, std::pair<K, T> >::asptr(items, val);
-	} else {
-	  map_type *p;
-	  res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<map_type>(),0);
-	  if (SWIG_IsOK(res) && val)  *val = p;
-	}
-	return res;
-	*/
-	return SWIG_ERROR;
-      }      
-    };
-      
-    template <class K, class T >
-    struct traits_from<std::map<K,T> >  {
-      typedef std::map<K,T> map_type;
-      typedef typename map_type::const_iterator const_iterator;
-      typedef typename map_type::size_type size_type;
-            
-      static octave_value from(const map_type& map) {
-	/*
-	swig_type_info *desc = swig::type_info<map_type>();
-	if (desc && desc->clientdata) {
-	  return SWIG_NewPointerObj(new map_type(map), desc, SWIG_POINTER_OWN);
-	} else {
-	  size_type size = map.size();
-	  int pysize = (size <= (size_type) INT_MAX) ? (int) size : -1;
-	  if (pysize < 0) {
-	    SWIG_PYTHON_THREAD_BEGIN_BLOCK;
-	    PyErr_SetString(PyExc_OverflowError,
-			    "map size not valid in python");
-	    SWIG_PYTHON_THREAD_END_BLOCK;
-	    return NULL;
-	  }
-	  PyObject *obj = PyDict_New();
-	  for (const_iterator i= map.begin(); i!= map.end(); ++i) {
-	    swig::SwigVar_PyObject key = swig::from(i->first);
-	    swig::SwigVar_PyObject val = swig::from(i->second);
-	    PyDict_SetItem(obj, key, val);
-	  }
-	  return obj;
-	}
-	*/
-	return octave_value();
-      }
-    };
-  }
-}
-
-%define %swig_map_common(Map...)
-  %swig_sequence_iterator(Map);
-  %swig_container_methods(Map);
-%enddef
-
-%define %swig_map_methods(Map...)
-     %swig_map_common(Map)
-%enddef
-
-
-%include <std/std_map.i>
diff --git a/share/swig/2.0.11/octave/std_pair.i b/share/swig/2.0.11/octave/std_pair.i
deleted file mode 100644
index ab028d1..0000000
--- a/share/swig/2.0.11/octave/std_pair.i
+++ /dev/null
@@ -1,129 +0,0 @@
-// Pairs
-
-%include <octstdcommon.swg>
-
-//#define SWIG_STD_PAIR_ASVAL
-
-%fragment("StdPairTraits","header",fragment="StdTraits") {
-  namespace swig {
-#ifdef SWIG_STD_PAIR_ASVAL
-    template <class T, class U >
-    struct traits_asval<std::pair<T,U> >  {
-      typedef std::pair<T,U> value_type;
-
-      static int get_pair(const octave_value& first, octave_value second,
-			  std::pair<T,U> *val)
-      {
-	if (val) {
-	  T *pfirst = &(val->first);
-	  int res1 = swig::asval(first, pfirst);
-	  if (!SWIG_IsOK(res1))
-	    return res1;
-	  U *psecond = &(val->second);
-	  int res2 = swig::asval(second, psecond);
-	  if (!SWIG_IsOK(res2))
-	    return res2;
-	  return res1 > res2 ? res1 : res2;
-	} else {
-	  T *pfirst = 0;
-	  int res1 = swig::asval(first, pfirst);
-	  if (!SWIG_IsOK(res1))
-	    return res1;
-	  U *psecond = 0;
-	  int res2 = swig::asval((PyObject*)second, psecond);
-	  if (!SWIG_IsOK(res2))
-	    return res2;
-	  return res1 > res2 ? res1 : res2;
-	}
-      }
-
-      static int asval(const octave_value& obj, std::pair<T,U> *val) {
-	if (obj.is_cell()) {
-	  Cell c=obj.cell_value();
-	  if (c.numel()<2) {
-	    error("pair from Cell array requires at least two elements");
-	    return SWIG_ERROR;
-	  }
-	  return get_pair(c(0),c(1),val);
-	} else {
-	  value_type *p;
-	  int res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<value_type>(),0);
-	  if (SWIG_IsOK(res) && val)
-	    *val = *p;
-	  return res;
-	}
-	return SWIG_ERROR;
-      }
-    };
-
-#else
-    template <class T, class U >
-    struct traits_asptr<std::pair<T,U> >  {
-      typedef std::pair<T,U> value_type;
-
-      static int get_pair(const octave_value& first, octave_value second,
-			  std::pair<T,U> **val) 
-      {
-	if (val) {
-	  value_type *vp = %new_instance(std::pair<T,U>);
-	  T *pfirst = &(vp->first);
-	  int res1 = swig::asval(first, pfirst);
-	  if (!SWIG_IsOK(res1))
-	    return res1;
-	  U *psecond = &(vp->second);
-	  int res2 = swig::asval(second, psecond);
-	  if (!SWIG_IsOK(res2))
-	    return res2;
-	  *val = vp;
-	  return SWIG_AddNewMask(res1 > res2 ? res1 : res2);
-	} else {
-	  T *pfirst = 0;
-	  int res1 = swig::asval(first, pfirst);
-	  if (!SWIG_IsOK(res1))
-	    return res1;
-	  U *psecond = 0;
-	  int res2 = swig::asval(second, psecond);
-	  if (!SWIG_IsOK(res2))
-	    return res2;
-	  return res1 > res2 ? res1 : res2;
-	}
-	return SWIG_ERROR;
-      }
-
-      static int asptr(const octave_value& obj, std::pair<T,U> **val) {
-	if (obj.is_cell()) {
-	  Cell c=obj.cell_value();
-	  if (c.numel()<2) {
-	    error("pair from Cell array requires at least two elements");
-	    return SWIG_ERROR;
-	  }
-	  return get_pair(c(0),c(1),val);
-	} else {
-	  value_type *p;
-	  int res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<value_type>(),0);
-	  if (SWIG_IsOK(res) && val)
-	    *val = p;
-	  return res;
-	}
-	return SWIG_ERROR;
-      }
-    };
-
-#endif
-    template <class T, class U >
-    struct traits_from<std::pair<T,U> >   {
-      static octave_value from(const std::pair<T,U>& val) {
-	Cell c(1,2);
-	c(0)=swig::from(val.first);
-	c(1)=swig::from(val.second);
-	return c;
-      }
-    };
-  }
-}
-
-%define %swig_pair_methods(pair...)
-%enddef
-
-%include <std/std_pair.i>
-
diff --git a/share/swig/2.0.11/perl5/Makefile.pl b/share/swig/2.0.11/perl5/Makefile.pl
deleted file mode 100644
index 05240f1..0000000
--- a/share/swig/2.0.11/perl5/Makefile.pl
+++ /dev/null
@@ -1,21 +0,0 @@
-# File : Makefile.pl
-# MakeMaker file for a SWIG module.  Use this file if you are
-# producing a module for general use or distribution.
-#
-# 1.  Modify the file as appropriate. Replace $module with the
-#     real name of your module and wrapper file.
-# 2.  Run perl as 'perl Makefile.pl'
-# 3.  Type 'make' to build your module
-# 4.  Type 'make install' to install your module.
-# 
-# See "Programming Perl", 2nd. Ed, for more gory details than
-# you ever wanted to know.
-
-use ExtUtils::MakeMaker;
-WriteMakefile(
-     'NAME' => '$module',            # Name of your module
-     'LIBS' => [''],                 # Custom libraries (if any)
-     'OBJECT' => '$module_wrap.o'    # Object files
-);
-
-
diff --git a/share/swig/2.0.11/perl5/noembed.h b/share/swig/2.0.11/perl5/noembed.h
deleted file mode 100644
index 936d50b..0000000
--- a/share/swig/2.0.11/perl5/noembed.h
+++ /dev/null
@@ -1,113 +0,0 @@
-/* Workaround perl5 global namespace pollution. Note that undefining library
- * functions like fopen will not solve the problem on all platforms as fopen
- * might be a macro on Windows but not necessarily on other operating systems. */
-#ifdef do_open
-  #undef do_open
-#endif
-#ifdef do_close
-  #undef do_close
-#endif
-#ifdef do_exec
-  #undef do_exec
-#endif
-#ifdef scalar
-  #undef scalar
-#endif
-#ifdef list
-  #undef list
-#endif
-#ifdef apply
-  #undef apply
-#endif
-#ifdef convert
-  #undef convert
-#endif
-#ifdef Error
-  #undef Error
-#endif
-#ifdef form
-  #undef form
-#endif
-#ifdef vform
-  #undef vform
-#endif
-#ifdef LABEL
-  #undef LABEL
-#endif
-#ifdef METHOD
-  #undef METHOD
-#endif
-#ifdef Move
-  #undef Move
-#endif
-#ifdef yylex
-  #undef yylex
-#endif
-#ifdef yyparse
-  #undef yyparse
-#endif
-#ifdef yyerror
-  #undef yyerror
-#endif
-#ifdef invert
-  #undef invert
-#endif
-#ifdef ref
-  #undef ref
-#endif
-#ifdef read
-  #undef read
-#endif
-#ifdef write
-  #undef write
-#endif
-#ifdef eof
-  #undef eof
-#endif
-#ifdef close
-  #undef close
-#endif
-#ifdef rewind
-  #undef rewind
-#endif
-#ifdef free
-  #undef free
-#endif
-#ifdef malloc
-  #undef malloc
-#endif
-#ifdef calloc
-  #undef calloc
-#endif
-#ifdef Stat
-  #undef Stat
-#endif
-#ifdef check
-  #undef check
-#endif
-#ifdef seekdir
-  #undef seekdir
-#endif
-#ifdef open
-  #undef open
-#endif
-#ifdef readdir
-  #undef readdir
-#endif
-#ifdef bind
-  #undef bind
-#endif
-#ifdef access
-  #undef access
-#endif
-#ifdef stat
-  #undef stat
-#endif
-
-#ifdef bool
-  /* Leave if macro is from C99 stdbool.h */
-  #ifndef __bool_true_false_are_defined
-    #undef bool
-  #endif
-#endif
-
diff --git a/share/swig/2.0.11/perl5/perlinit.swg b/share/swig/2.0.11/perl5/perlinit.swg
deleted file mode 100644
index d9ffa9b..0000000
--- a/share/swig/2.0.11/perl5/perlinit.swg
+++ /dev/null
@@ -1,81 +0,0 @@
-
-/* Export the SWIG initialization function */
-%header %{
-#ifdef __cplusplus
-extern "C"
-#endif
-#ifndef PERL_OBJECT
-#ifndef MULTIPLICITY
-SWIGEXPORT void SWIG_init (CV* cv);
-#else
-SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
-#endif
-#else
-SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
-#endif
-%}
-
-/* Module initialization function */
-
-%insert(init) "swiginit.swg"
-
-%init %{
-
-#ifdef __cplusplus
-extern "C"
-#endif
-
-XS(SWIG_init) {
-    dXSARGS;
-    int i;
-
-    SWIG_InitializeModule(0);
-
-    /* Install commands */
-    for (i = 0; swig_commands[i].name; i++) {
-      /* Casts only needed for Perl < 5.10. */
-#ifdef __cplusplus
-      newXS(const_cast<char*>(swig_commands[i].name), swig_commands[i].wrapper, const_cast<char*>(__FILE__));
-#else
-      newXS((char*)swig_commands[i].name, swig_commands[i].wrapper, (char*)__FILE__);
-#endif
-    }
-
-    /* Install variables */
-    for (i = 0; swig_variables[i].name; i++) {
-      SV *sv;
-      sv = get_sv(swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
-      if (swig_variables[i].type) {
-	SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
-      } else {
-	sv_setiv(sv,(IV) 0);
-      }
-      swig_create_magic(sv, swig_variables[i].name, swig_variables[i].set, swig_variables[i].get); 
-    }
-
-    /* Install constant */
-    for (i = 0; swig_constants[i].type; i++) {
-      SV *sv;
-      sv = get_sv(swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
-      switch(swig_constants[i].type) {
-      case SWIG_INT:
-	sv_setiv(sv, (IV) swig_constants[i].lvalue);
-	break;
-      case SWIG_FLOAT:
-	sv_setnv(sv, (double) swig_constants[i].dvalue);
-	break;
-      case SWIG_STRING:
-	sv_setpv(sv, (const char *) swig_constants[i].pvalue);
-	break;
-      case SWIG_POINTER:
-	SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
-	break;
-      case SWIG_BINARY:
-	SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
-	break;
-      default:
-	break;
-      }
-      SvREADONLY_on(sv);
-    }
-%}
diff --git a/share/swig/2.0.11/perl5/perlprimtypes.swg b/share/swig/2.0.11/perl5/perlprimtypes.swg
deleted file mode 100644
index d7ac6f9..0000000
--- a/share/swig/2.0.11/perl5/perlprimtypes.swg
+++ /dev/null
@@ -1,352 +0,0 @@
-/* ------------------------------------------------------------
- * Primitive Types
- * ------------------------------------------------------------ */
-
-/* bool */
-
-%fragment(SWIG_From_frag(bool),"header") {
-SWIGINTERNINLINE SV *
-SWIG_From_dec(bool)(bool value)
-{
-  return boolSV(value);
-}
-}
-
-%fragment(SWIG_AsVal_frag(bool),"header") {
-SWIGINTERN int
-SWIG_AsVal_dec(bool)(SV *obj, bool* val)
-{
-  if (obj == &PL_sv_yes) {
-    if (val) *val = true;
-    return SWIG_OK;
-  } else if (obj == &PL_sv_no) { 
-    if (val) *val = false;
-    return SWIG_OK;
-  } else {
-    if (val) *val = SvTRUE(obj) ? true : false;
-    return SWIG_AddCast(SWIG_OK);    
-  }
-}
-}
-
-
-/* long */
-
-%fragment(SWIG_From_frag(long),"header") {
-SWIGINTERNINLINE SV *
-SWIG_From_dec(long)(long value)
-{
-  SV *sv;
-  if (value >= IV_MIN && value <= IV_MAX)
-    sv = newSViv(value);
-  else
-    sv = newSVpvf("%ld", value);
-  return sv_2mortal(sv);
-}
-}
-
-%fragment(SWIG_AsVal_frag(long),"header",
-	  fragment="SWIG_CanCastAsInteger") {
-SWIGINTERN int
-SWIG_AsVal_dec(long)(SV *obj, long* val)
-{
-  if (SvUOK(obj)) {
-    UV v = SvUV(obj);
-    if (v <= LONG_MAX) {
-      if (val) *val = v;
-      return SWIG_OK;
-    }
-    return SWIG_OverflowError;
-  } else if (SvIOK(obj)) {
-    IV v = SvIV(obj);
-    if (v >= LONG_MIN && v <= LONG_MAX) {
-      if(val) *val = v;
-      return SWIG_OK;
-    }
-    return SWIG_OverflowError;
-  } else {
-    int dispatch = 0;
-    const char *nptr = SvPV_nolen(obj);
-    if (nptr) {
-      char *endptr;
-      long v;
-      errno = 0;
-      v = strtol(nptr, &endptr,0);
-      if (errno == ERANGE) {
-	errno = 0;
-	return SWIG_OverflowError;
-      } else {
-	if (*endptr == '\0') {
-	  if (val) *val = v;
-	  return SWIG_Str2NumCast(SWIG_OK);
-	}
-      }
-    }
-    if (!dispatch) {
-      double d;
-      int res = SWIG_AddCast(SWIG_AsVal(double)(obj,&d));
-      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
-	if (val) *val = (long)(d);
-	return res;
-      }
-    }
-  }
-  return SWIG_TypeError;
-}
-}
-
-/* unsigned long */
-
-%fragment(SWIG_From_frag(unsigned long),"header") {
-SWIGINTERNINLINE SV *
-SWIG_From_dec(unsigned long)(unsigned long value)
-{
-  SV *sv;
-  if (value <= UV_MAX)
-    sv = newSVuv(value);
-  else
-    sv = newSVpvf("%lu", value);
-  return sv_2mortal(sv);
-}
-}
-
-%fragment(SWIG_AsVal_frag(unsigned long),"header",
-	  fragment="SWIG_CanCastAsInteger") {
-SWIGINTERN int
-SWIG_AsVal_dec(unsigned long)(SV *obj, unsigned long *val) 
-{
-  if (SvUOK(obj)) {
-    UV v = SvUV(obj);
-    if (v <= ULONG_MAX) {
-      if (val) *val = v;
-      return SWIG_OK;
-    }
-    return SWIG_OverflowError;
-  } else if (SvIOK(obj)) {
-    IV v = SvIV(obj);
-    if (v >= 0 && v <= ULONG_MAX) {
-      if (val) *val = v;
-      return SWIG_OK;
-    }
-    return SWIG_OverflowError;
-  } else {
-    int dispatch = 0;
-    const char *nptr = SvPV_nolen(obj);
-    if (nptr) {
-      char *endptr;
-      unsigned long v;
-      errno = 0;
-      v = strtoul(nptr, &endptr,0);
-      if (errno == ERANGE) {
-	errno = 0;
-	return SWIG_OverflowError;
-      } else {
-	if (*endptr == '\0') {
-	  if (val) *val = v;
-	  return SWIG_Str2NumCast(SWIG_OK);
-	}
-      }
-    }
-    if (!dispatch) {
-      double d;
-      int res = SWIG_AddCast(SWIG_AsVal(double)(obj,&d));
-      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
-	if (val) *val = (unsigned long)(d);
-	return res;
-      }
-    }
-  }
-  return SWIG_TypeError;
-}
-}
-
-/* long long */
-
-%fragment(SWIG_From_frag(long long),"header",
-	  fragment=SWIG_From_frag(long),
-	  fragment="<limits.h>",
-	  fragment="<stdio.h>") {
-SWIGINTERNINLINE SV *
-SWIG_From_dec(long long)(long long value)
-{
-  SV *sv;
-  if (value >= IV_MIN && value <= IV_MAX)
-    sv = newSViv((IV)(value));
-  else {
-    //sv = newSVpvf("%lld", value); doesn't work in non 64bit Perl
-    char temp[256];
-    sprintf(temp, "%lld", value);
-    sv = newSVpv(temp, 0);
-  }
-  return sv_2mortal(sv);
-}
-}
-
-%fragment(SWIG_AsVal_frag(long long),"header",
-	  fragment="<limits.h>",
-	  fragment="<stdlib.h>",
-	  fragment="SWIG_CanCastAsInteger") {
-
-SWIGINTERN int
-SWIG_AsVal_dec(long long)(SV *obj, long long *val)
-{
-  if (SvUOK(obj)) {
-    UV v = SvUV(obj);
-    if (v < LLONG_MAX) {
-      if (val) *val = v;
-      return SWIG_OK;
-    }
-    return SWIG_OverflowError;
-  } else if (SvIOK(obj)) {
-    IV v = SvIV(obj);
-    if (v >= LLONG_MIN && v <= LLONG_MAX) {
-      if (val) *val = v;
-      return SWIG_OK;
-    }
-    return SWIG_OverflowError;
-  } else {
-    int dispatch = 0;
-    const char *nptr = SvPV_nolen(obj);
-    if (nptr) {
-      char *endptr;
-      long long v;
-      errno = 0;
-      v = strtoll(nptr, &endptr,0);
-      if (errno == ERANGE) {
-	errno = 0;
-	return SWIG_OverflowError;
-      } else {
-	if (*endptr == '\0') {
-	  if (val) *val = v;
-	  return SWIG_Str2NumCast(SWIG_OK);
-	}
-      }
-    }
-    if (!dispatch) {
-      const double mant_max = 1LL << DBL_MANT_DIG;
-      const double mant_min = -mant_max;
-      double d;
-      int res = SWIG_AddCast(SWIG_AsVal(double)(obj,&d));
-      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
-	if (val) *val = (long long)(d);
-	return res;
-      }
-    }
-  }
-  return SWIG_TypeError; 
-}
-}
-
-/* unsigned long long */
-
-%fragment(SWIG_From_frag(unsigned long long),"header",
-	  fragment=SWIG_From_frag(long long),
-	  fragment="<limits.h>",
-	  fragment="<stdio.h>") {
-SWIGINTERNINLINE SV *
-SWIG_From_dec(unsigned long long)(unsigned long long value)
-{
-  SV *sv;
-  if (value <= UV_MAX)
-    sv = newSVuv((UV)(value));
-  else {
-    //sv = newSVpvf("%llu", value); doesn't work in non 64bit Perl
-    char temp[256];
-    sprintf(temp, "%llu", value);
-    sv = newSVpv(temp, 0);
-  }
-  return sv_2mortal(sv);
-}
-}
-
-%fragment(SWIG_AsVal_frag(unsigned long long),"header",
-	  fragment="<limits.h>",
-	  fragment="<stdlib.h>",
-	  fragment="SWIG_CanCastAsInteger") {
-SWIGINTERN int
-SWIG_AsVal_dec(unsigned long long)(SV *obj, unsigned long long *val)
-{
-  if (SvUOK(obj)) {
-    if (val) *val = SvUV(obj);
-    return SWIG_OK;
-  } else  if (SvIOK(obj)) {
-    IV v = SvIV(obj);
-    if (v >= 0 && v <= ULLONG_MAX) {
-      if (val) *val = v;
-      return SWIG_OK;
-    } else {
-      return SWIG_OverflowError;
-    }
-  } else {
-    int dispatch = 0;
-    const char *nptr = SvPV_nolen(obj);
-    if (nptr) {
-      char *endptr;
-      unsigned long long v;
-      errno = 0;
-      v = strtoull(nptr, &endptr,0);
-      if (errno == ERANGE) {
-	errno = 0;
-	return SWIG_OverflowError;
-      } else {
-	if (*endptr == '\0') {
-	  if (val) *val = v;
-	  return SWIG_Str2NumCast(SWIG_OK);
-	}
-      }
-    }
-    if (!dispatch) {
-      const double mant_max = 1LL << DBL_MANT_DIG;
-      double d;
-      int res = SWIG_AddCast(SWIG_AsVal(double)(obj,&d));
-      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
-	if (val) *val = (unsigned long long)(d);
-	return res;
-      }
-    }
-  }
-  return SWIG_TypeError;
-}
-}
-
-/* double */
-
-%fragment(SWIG_From_frag(double),"header") {
-SWIGINTERNINLINE SV *
-SWIG_From_dec(double)(double value)
-{
-  return sv_2mortal(newSVnv(value));
-}
-}
-
-%fragment(SWIG_AsVal_frag(double),"header") {
-SWIGINTERN int
-SWIG_AsVal_dec(double)(SV *obj, double *val)
-{
-  if (SvNIOK(obj)) {
-    if (val) *val = SvNV(obj);
-    return SWIG_OK;
-  } else if (SvIOK(obj)) {
-    if (val) *val = (double) SvIV(obj);
-    return SWIG_AddCast(SWIG_OK);
-  } else {
-    const char *nptr = SvPV_nolen(obj);
-    if (nptr) {
-      char *endptr;
-      double v;
-      errno = 0;
-      v = strtod(nptr, &endptr);
-      if (errno == ERANGE) {
-	errno = 0;
-	return SWIG_OverflowError;
-      } else {
-	if (*endptr == '\0') {
-	  if (val) *val = v;
-	  return SWIG_Str2NumCast(SWIG_OK);
-	}
-      }
-    }
-  }
-  return SWIG_TypeError;
-}
-}
diff --git a/share/swig/2.0.11/perl5/perlrun.swg b/share/swig/2.0.11/perl5/perlrun.swg
deleted file mode 100644
index ebc4fec..0000000
--- a/share/swig/2.0.11/perl5/perlrun.swg
+++ /dev/null
@@ -1,506 +0,0 @@
-/* -----------------------------------------------------------------------------
- * perlrun.swg
- *
- * This file contains the runtime support for Perl modules
- * and includes code for managing global variables and pointer
- * type checking.
- * ----------------------------------------------------------------------------- */
-
-#ifdef PERL_OBJECT
-#define SWIG_PERL_OBJECT_DECL CPerlObj *SWIGUNUSEDPARM(pPerl),
-#define SWIG_PERL_OBJECT_CALL pPerl,
-#else
-#define SWIG_PERL_OBJECT_DECL
-#define SWIG_PERL_OBJECT_CALL
-#endif
-
-/* Common SWIG API */
-
-/* for raw pointers */
-#define SWIG_ConvertPtr(obj, pp, type, flags)           SWIG_Perl_ConvertPtr(SWIG_PERL_OBJECT_CALL obj, pp, type, flags)
-#define SWIG_ConvertPtrAndOwn(obj, pp, type, flags,own) SWIG_Perl_ConvertPtrAndOwn(SWIG_PERL_OBJECT_CALL obj, pp, type, flags, own)
-#define SWIG_NewPointerObj(p, type, flags)              SWIG_Perl_NewPointerObj(SWIG_PERL_OBJECT_CALL p, type, flags)
-
-/* for raw packed data */
-#define SWIG_ConvertPacked(obj, p, s, type)             SWIG_Perl_ConvertPacked(SWIG_PERL_OBJECT_CALL obj, p, s, type)
-#define SWIG_NewPackedObj(p, s, type)	                SWIG_Perl_NewPackedObj(SWIG_PERL_OBJECT_CALL p, s, type)
-
-/* for class or struct pointers */
-#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
-#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
-
-/* for C or C++ function pointers */
-#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
-#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
-
-/* for C++ member pointers, ie, member methods */
-#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_ConvertPacked(obj, ptr, sz, ty)
-#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_NewPackedObj(ptr, sz, type)
-
-
-/* Runtime API */
-
-#define SWIG_GetModule(clientdata)                      SWIG_Perl_GetModule(clientdata)
-#define SWIG_SetModule(clientdata, pointer)             SWIG_Perl_SetModule(pointer)
-
-
-/* Error manipulation */
-
-#define SWIG_ErrorType(code)                            SWIG_Perl_ErrorType(code)               
-#define SWIG_Error(code, msg)            		sv_setpvf(get_sv("@", GV_ADD), "%s %s", SWIG_ErrorType(code), msg)
-#define SWIG_fail                        		goto fail						    
-
-/* Perl-specific SWIG API */
-
-#define SWIG_MakePtr(sv, ptr, type, flags)              SWIG_Perl_MakePtr(SWIG_PERL_OBJECT_CALL sv, ptr, type, flags)
-#define SWIG_MakePackedObj(sv, p, s, type)	        SWIG_Perl_MakePackedObj(SWIG_PERL_OBJECT_CALL sv, p, s, type)
-#define SWIG_SetError(str)                              SWIG_Error(SWIG_RuntimeError, str)
-
-
-#define SWIG_PERL_DECL_ARGS_1(arg1)                     (SWIG_PERL_OBJECT_DECL arg1)
-#define SWIG_PERL_CALL_ARGS_1(arg1)                     (SWIG_PERL_OBJECT_CALL arg1)
-#define SWIG_PERL_DECL_ARGS_2(arg1, arg2)               (SWIG_PERL_OBJECT_DECL arg1, arg2)
-#define SWIG_PERL_CALL_ARGS_2(arg1, arg2)               (SWIG_PERL_OBJECT_CALL arg1, arg2)
-
-/* -----------------------------------------------------------------------------
- * pointers/data manipulation
- * ----------------------------------------------------------------------------- */
-
-/* For backward compatibility only */
-#define SWIG_POINTER_EXCEPTION  0
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define SWIG_OWNER   SWIG_POINTER_OWN
-#define SWIG_SHADOW  SWIG_OWNER << 1
-
-#define SWIG_MAYBE_PERL_OBJECT SWIG_PERL_OBJECT_DECL
-
-/* SWIG Perl macros */
-
-/* Macro to declare an XS function */
-#ifndef XSPROTO
-#   define XSPROTO(name) void name(pTHX_ CV* cv)
-#endif
-
-/* Macro to call an XS function */
-#ifdef PERL_OBJECT 
-#  define SWIG_CALLXS(_name) _name(cv,pPerl) 
-#else 
-#  ifndef MULTIPLICITY 
-#    define SWIG_CALLXS(_name) _name(cv) 
-#  else 
-#    define SWIG_CALLXS(_name) _name(PERL_GET_THX, cv) 
-#  endif 
-#endif 
-
-#ifdef PERL_OBJECT
-#define MAGIC_PPERL  CPerlObj *pPerl = (CPerlObj *) this;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-typedef int (CPerlObj::*SwigMagicFunc)(SV *, MAGIC *);
-#ifdef __cplusplus
-}
-#endif
-
-#define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
-#define SWIGCLASS_STATIC
-
-#else /* PERL_OBJECT */
-
-#define MAGIC_PPERL
-#define SWIGCLASS_STATIC static SWIGUNUSED
-
-#ifndef MULTIPLICITY
-#define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-typedef int (*SwigMagicFunc)(SV *, MAGIC *);
-#ifdef __cplusplus
-}
-#endif
-
-#else /* MULTIPLICITY */
-
-#define SWIG_MAGIC(a,b) (struct interpreter *interp, SV *a, MAGIC *b)
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *);
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* MULTIPLICITY */
-#endif /* PERL_OBJECT */
-
-#  ifdef PERL_OBJECT
-#    define SWIG_croak_null() SWIG_Perl_croak_null(pPerl)
-static void SWIG_Perl_croak_null(CPerlObj *pPerl)
-#  else
-static void SWIG_croak_null()
-#  endif
-{
-  SV *err = get_sv("@", GV_ADD);
-#  if (PERL_VERSION < 6)
-  croak("%_", err);
-#  else
-  if (sv_isobject(err))
-    croak(0);
-  else
-    croak("%s", SvPV_nolen(err));
-#  endif
-}
-
-
-/* 
-   Define how strict is the cast between strings and integers/doubles
-   when overloading between these types occurs.
-   
-   The default is making it as strict as possible by using SWIG_AddCast
-   when needed.
-   
-   You can use -DSWIG_PERL_NO_STRICT_STR2NUM at compilation time to
-   disable the SWIG_AddCast, making the casting between string and
-   numbers less strict.
-
-   In the end, we try to solve the overloading between strings and
-   numerical types in the more natural way, but if you can avoid it,
-   well, avoid it using %rename, for example.
-*/
-#ifndef SWIG_PERL_NO_STRICT_STR2NUM
-# ifndef SWIG_PERL_STRICT_STR2NUM
-#  define SWIG_PERL_STRICT_STR2NUM
-# endif
-#endif
-#ifdef SWIG_PERL_STRICT_STR2NUM
-/* string takes precedence */
-#define SWIG_Str2NumCast(x) SWIG_AddCast(x)  
-#else
-/* number takes precedence */
-#define SWIG_Str2NumCast(x) x
-#endif
-
-
-
-#include <stdlib.h>
-
-SWIGRUNTIME const char *
-SWIG_Perl_TypeProxyName(const swig_type_info *type) {
-  if (!type) return NULL;
-  if (type->clientdata != NULL) {
-    return (const char*) type->clientdata;
-  } 
-  else {
-    return type->name;
-  }
-}
-
-/* Identical to SWIG_TypeCheck, except for strcmp comparison */
-SWIGRUNTIME swig_cast_info *
-SWIG_TypeProxyCheck(const char *c, swig_type_info *ty) {
-  if (ty) {
-    swig_cast_info *iter = ty->cast;
-    while (iter) {
-      if (strcmp(SWIG_Perl_TypeProxyName(iter->type), c) == 0) {
-        if (iter == ty->cast)
-          return iter;
-        /* Move iter to the top of the linked list */
-        iter->prev->next = iter->next;
-        if (iter->next)
-          iter->next->prev = iter->prev;
-        iter->next = ty->cast;
-        iter->prev = 0;
-        if (ty->cast) ty->cast->prev = iter;
-        ty->cast = iter;
-        return iter;
-      }
-      iter = iter->next;
-    }
-  }
-  return 0;
-}
-
-/* Function for getting a pointer value */
-
-SWIGRUNTIME int
-SWIG_Perl_ConvertPtrAndOwn(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags, int *own) {
-  swig_cast_info *tc;
-  void *voidptr = (void *)0;
-  SV *tsv = 0;
-
-  if (own)
-    *own = 0;
-
-  /* If magical, apply more magic */
-  if (SvGMAGICAL(sv))
-    mg_get(sv);
-
-  /* Check to see if this is an object */
-  if (sv_isobject(sv)) {
-    IV tmp = 0;
-    tsv = (SV*) SvRV(sv);
-    if ((SvTYPE(tsv) == SVt_PVHV)) {
-      MAGIC *mg;
-      if (SvMAGICAL(tsv)) {
-        mg = mg_find(tsv,'P');
-        if (mg) {
-          sv = mg->mg_obj;
-          if (sv_isobject(sv)) {
-	    tsv = (SV*)SvRV(sv);
-            tmp = SvIV(tsv);
-          }
-        }
-      } else {
-        return SWIG_ERROR;
-      }
-    } else {
-      tmp = SvIV(tsv);
-    }
-    voidptr = INT2PTR(void *,tmp);
-  } else if (! SvOK(sv)) {            /* Check for undef */
-    *(ptr) = (void *) 0;
-    return SWIG_OK;
-  } else if (SvTYPE(sv) == SVt_RV) {  /* Check for NULL pointer */
-    if (!SvROK(sv)) {
-      /* In Perl 5.12 and later, SVt_RV == SVt_IV, so sv could be a valid integer value.  */
-      if (SvIOK(sv)) {
-        return SWIG_ERROR;
-      } else {
-        /* NULL pointer (reference to undef). */
-        *(ptr) = (void *) 0;
-        return SWIG_OK;
-      }
-    } else {
-      return SWIG_ERROR;
-    }
-  } else {                            /* Don't know what it is */
-    return SWIG_ERROR;
-  }
-  if (_t) {
-    /* Now see if the types match */
-    char *_c = HvNAME(SvSTASH(SvRV(sv)));
-    tc = SWIG_TypeProxyCheck(_c,_t);
-    if (!tc) {
-      return SWIG_ERROR;
-    }
-    {
-      int newmemory = 0;
-      *ptr = SWIG_TypeCast(tc,voidptr,&newmemory);
-      if (newmemory == SWIG_CAST_NEW_MEMORY) {
-        assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
-        if (own)
-          *own = *own | SWIG_CAST_NEW_MEMORY;
-      }
-    }
-  } else {
-    *ptr = voidptr;
-  }
-
-  /* 
-   *  DISOWN implementation: we need a perl guru to check this one.
-   */
-  if (tsv && (flags & SWIG_POINTER_DISOWN)) {
-    /* 
-     *  almost copy paste code from below SWIG_POINTER_OWN setting
-     */
-    SV *obj = sv;
-    HV *stash = SvSTASH(SvRV(obj));
-    GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
-    if (isGV(gv)) {
-      HV *hv = GvHVn(gv);
-      /*
-       * To set ownership (see below), a newSViv(1) entry is added. 
-       * Hence, to remove ownership, we delete the entry.
-       */
-      if (hv_exists_ent(hv, obj, 0)) {
-	hv_delete_ent(hv, obj, 0, 0);
-      }
-    }
-  }
-  return SWIG_OK;
-}
-
-SWIGRUNTIME int
-SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
-  return SWIG_Perl_ConvertPtrAndOwn(sv, ptr, _t, flags, 0);
-}
-
-SWIGRUNTIME void
-SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
-  if (ptr && (flags & (SWIG_SHADOW | SWIG_POINTER_OWN))) {
-    SV *self;
-    SV *obj=newSV(0);
-    HV *hash=newHV();
-    HV *stash;
-    sv_setref_pv(obj, SWIG_Perl_TypeProxyName(t), ptr);
-    stash=SvSTASH(SvRV(obj));
-    if (flags & SWIG_POINTER_OWN) {
-      HV *hv;
-      GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
-      if (!isGV(gv))
-        gv_init(gv, stash, "OWNER", 5, FALSE);
-      hv=GvHVn(gv);
-      hv_store_ent(hv, obj, newSViv(1), 0);
-    }
-    sv_magic((SV *)hash, (SV *)obj, 'P', Nullch, 0);
-    SvREFCNT_dec(obj);
-    self=newRV_noinc((SV *)hash);
-    sv_setsv(sv, self);
-    SvREFCNT_dec((SV *)self);
-    sv_bless(sv, stash);
-  }
-  else {
-    sv_setref_pv(sv, SWIG_Perl_TypeProxyName(t), ptr);
-  }
-}
-
-SWIGRUNTIMEINLINE SV *
-SWIG_Perl_NewPointerObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
-  SV *result = sv_newmortal();
-  SWIG_MakePtr(result, ptr, t, flags);
-  return result;
-}
-
-SWIGRUNTIME void
-SWIG_Perl_MakePackedObj(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, int sz, swig_type_info *type) {
-  char result[1024];
-  char *r = result;
-  if ((2*sz + 1 + strlen(SWIG_Perl_TypeProxyName(type))) > 1000) return;
-  *(r++) = '_';
-  r = SWIG_PackData(r,ptr,sz);
-  strcpy(r,SWIG_Perl_TypeProxyName(type));
-  sv_setpv(sv, result);
-}
-
-SWIGRUNTIME SV *
-SWIG_Perl_NewPackedObj(SWIG_MAYBE_PERL_OBJECT void *ptr, int sz, swig_type_info *type) {
-  SV *result = sv_newmortal();
-  SWIG_Perl_MakePackedObj(result, ptr, sz, type);
-  return result;
-}
-
-/* Convert a packed value value */
-SWIGRUNTIME int
-SWIG_Perl_ConvertPacked(SWIG_MAYBE_PERL_OBJECT SV *obj, void *ptr, int sz, swig_type_info *ty) {
-  swig_cast_info *tc;
-  const char  *c = 0;
-
-  if ((!obj) || (!SvOK(obj))) return SWIG_ERROR;
-  c = SvPV_nolen(obj);
-  /* Pointer values must start with leading underscore */
-  if (*c != '_') return SWIG_ERROR;
-  c++;
-  c = SWIG_UnpackData(c,ptr,sz);
-  if (ty) {
-    tc = SWIG_TypeCheck(c,ty);
-    if (!tc) return SWIG_ERROR;
-  }
-  return SWIG_OK;
-}
-
-
-/* Macros for low-level exception handling */
-#define SWIG_croak(x)    { SWIG_Error(SWIG_RuntimeError, x); SWIG_fail; }
-
-
-typedef XSPROTO(SwigPerlWrapper);
-typedef SwigPerlWrapper *SwigPerlWrapperPtr;
-
-/* Structure for command table */
-typedef struct {
-  const char         *name;
-  SwigPerlWrapperPtr  wrapper;
-} swig_command_info;
-
-/* Information for constant table */
-
-#define SWIG_INT     1
-#define SWIG_FLOAT   2
-#define SWIG_STRING  3
-#define SWIG_POINTER 4
-#define SWIG_BINARY  5
-
-/* Constant information structure */
-typedef struct swig_constant_info {
-    int              type;
-    const char      *name;
-    long             lvalue;
-    double           dvalue;
-    void            *pvalue;
-    swig_type_info **ptype;
-} swig_constant_info;
-
-
-/* Structure for variable table */
-typedef struct {
-  const char   *name;
-  SwigMagicFunc   set;
-  SwigMagicFunc   get;
-  swig_type_info  **type;
-} swig_variable_info;
-
-/* Magic variable code */
-#ifndef PERL_OBJECT
-# ifdef __cplusplus
-#  define swig_create_magic(s,a,b,c) _swig_create_magic(s,const_cast<char*>(a),b,c)
-# else
-#  define swig_create_magic(s,a,b,c) _swig_create_magic(s,(char*)(a),b,c)
-# endif
-# ifndef MULTIPLICITY
-SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *)) 
-# else
-SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *)) 
-# endif
-#else
-#  define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
-SWIGRUNTIME void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *)) 
-#endif
-{
-  MAGIC *mg;
-  sv_magic(sv,sv,'U',name,strlen(name));
-  mg = mg_find(sv,'U');
-  mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
-  mg->mg_virtual->svt_get = (SwigMagicFunc) get;
-  mg->mg_virtual->svt_set = (SwigMagicFunc) set;
-  mg->mg_virtual->svt_len = 0;
-  mg->mg_virtual->svt_clear = 0;
-  mg->mg_virtual->svt_free = 0;
-}
-
-
-SWIGRUNTIME swig_module_info *
-SWIG_Perl_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
-  static void *type_pointer = (void *)0;
-  SV *pointer;
-
-  /* first check if pointer already created */
-  if (!type_pointer) {
-    pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE | GV_ADDMULTI);
-    if (pointer && SvOK(pointer)) {
-      type_pointer = INT2PTR(swig_type_info **, SvIV(pointer));
-    }
-  }
-
-  return (swig_module_info *) type_pointer;
-}
-
-SWIGRUNTIME void
-SWIG_Perl_SetModule(swig_module_info *module) {
-  SV *pointer;
-
-  /* create a new pointer */
-  pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TRUE | GV_ADDMULTI);
-  sv_setiv(pointer, PTR2IV(module));
-}
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/share/swig/2.0.11/perl5/perltypemaps.swg b/share/swig/2.0.11/perl5/perltypemaps.swg
deleted file mode 100644
index 5df456f..0000000
--- a/share/swig/2.0.11/perl5/perltypemaps.swg
+++ /dev/null
@@ -1,95 +0,0 @@
-/* ------------------------------------------------------------
- *  Typemap specializations for Perl
- * ------------------------------------------------------------ */
-
-/* ------------------------------------------------------------
- *  Fragment section
- * ------------------------------------------------------------ */
-
-/*
-  in Perl we need to pass the CPerlObj value, sometimes, so, we define
-  the decl/call macros as needed.
-*/
-
-#define SWIG_AS_DECL_ARGS SWIG_PERL_DECL_ARGS_2
-#define SWIG_AS_CALL_ARGS SWIG_PERL_CALL_ARGS_2
-
-#define SWIG_FROM_DECL_ARGS  SWIG_PERL_DECL_ARGS_1
-#define SWIG_FROM_CALL_ARGS  SWIG_PERL_CALL_ARGS_1
-
-
-/* Include fundamental fragemt definitions */
-%include <typemaps/fragments.swg>
-
-/* Look for user fragments file. */
-%include <perlfragments.swg>
-
-/* Perl fragments for primitive types */
-%include <perlprimtypes.swg>
-
-/* Perl fragments for char* strings */
-%include <perlstrings.swg>
-
-
-/* ------------------------------------------------------------
- *  Unified typemap section
- * ------------------------------------------------------------ */
-
-/* No director supported in Perl */
-#ifdef SWIG_DIRECTOR_TYPEMAPS
-#undef SWIG_DIRECTOR_TYPEMAPS
-#endif
-
-
-/* Perl types */
-#define SWIG_Object                      SV *
-#define VOID_Object                      sv_newmortal()
-
-/* Perl $shadow flag */
-#define %newpointer_flags                $shadow
-#define %newinstance_flags               $shadow
-
-
-/* Complete overload of the output/constant/exception macros */
-
-/* output */
-%define %set_output(obj) $result = obj; argvi++ %enddef
-
-/* append output */
-%define %append_output(obj) if (argvi >= items) EXTEND(sp,1); %set_output(obj) %enddef
-
-/* variable output */
-%define %set_varoutput(obj) sv_setsv($result,obj)  %enddef
-
-/* constant */
-%define %set_constant(name, obj) %begin_block
-  SV *sv = get_sv((char*) SWIG_prefix name, TRUE | 0x2 | GV_ADDMULTI);
-  sv_setsv(sv, obj);
-  SvREADONLY_on(sv);
-%end_block %enddef
-
-/* raise exception */
-%define %raise(obj, type, desc) sv_setsv(get_sv("@", GV_ADD), obj); SWIG_fail %enddef
-
-/* Include the unified typemap library */
-%include <typemaps/swigtypemaps.swg>
-
-/*  ------------------------------------------------------------
- *  Perl extra typemaps / typemap overrides
- * ------------------------------------------------------------ */
-
-%typemap(varout,type="$1_descriptor") SWIGTYPE *, SWIGTYPE []  
-    "sv_setiv(SvRV($result),PTR2IV($1));"; 
-
-%typemap(varout,type="$1_descriptor") SWIGTYPE &
-    "sv_setiv(SvRV($result),PTR2IV(&$1));"; 
-
-%typemap(varout,type="$&1_descriptor") SWIGTYPE
-    "sv_setiv(SvRV($result), PTR2IV(&$1));";
-
-%typemap(varout,type="$1_descriptor") SWIGTYPE (CLASS::*) {
-  SWIG_MakePackedObj($result, (void *) &$1, sizeof($1_type), $1_descriptor);
-}
-
-%typemap(varout) SWIGTYPE *const = SWIGTYPE *;
-
diff --git a/share/swig/2.0.11/perl5/std_common.i b/share/swig/2.0.11/perl5/std_common.i
deleted file mode 100644
index c365139..0000000
--- a/share/swig/2.0.11/perl5/std_common.i
+++ /dev/null
@@ -1,26 +0,0 @@
-/* -----------------------------------------------------------------------------
- * std_common.i
- *
- * SWIG typemaps for STL - common utilities
- * ----------------------------------------------------------------------------- */
-
-%include <std/std_except.i>
-
-%apply size_t { std::size_t };
-
-%{
-#include <string>
-
-double SwigSvToNumber(SV* sv) {
-    return SvIOK(sv) ? double(SvIVX(sv)) : SvNVX(sv);
-}
-std::string SwigSvToString(SV* sv) {
-    STRLEN len;
-    char *ptr = SvPV(sv, len);
-    return std::string(ptr, len);
-}
-void SwigSvFromString(SV* sv, const std::string& s) {
-    sv_setpvn(sv,s.data(),s.size());
-}
-%}
-
diff --git a/share/swig/2.0.11/perl5/std_list.i b/share/swig/2.0.11/perl5/std_list.i
deleted file mode 100644
index ea264d6..0000000
--- a/share/swig/2.0.11/perl5/std_list.i
+++ /dev/null
@@ -1,373 +0,0 @@
-/* -----------------------------------------------------------------------------
- * std_list.i
- *
- * SWIG typemaps for std::list types
- * ----------------------------------------------------------------------------- */
-
-%include <std_common.i>
-%include <exception.i>
-
-// containers
-
-
-// ------------------------------------------------------------------------
-// std::list
-// 
-// The aim of all that follows would be to integrate std::list with 
-// Perl as much as possible, namely, to allow the user to pass and 
-// be returned Perl arrays.
-// const declarations are used to guess the intent of the function being
-// exported; therefore, the following rationale is applied:
-// 
-//   -- f(std::list<T>), f(const std::list<T>&), f(const std::list<T>*):
-//      the parameter being read-only, either a Perl sequence or a
-//      previously wrapped std::list<T> can be passed.
-//   -- f(std::list<T>&), f(std::list<T>*):
-//      the parameter must be modified; therefore, only a wrapped std::list
-//      can be passed.
-//   -- std::list<T> f():
-//      the list is returned by copy; therefore, a Perl sequence of T:s 
-//      is returned which is most easily used in other Perl functions
-//   -- std::list<T>& f(), std::list<T>* f(), const std::list<T>& f(),
-//      const std::list<T>* f():
-//      the list is returned by reference; therefore, a wrapped std::list
-//      is returned
-// ------------------------------------------------------------------------
-
-%{
-#include <list>
-#include <algorithm>
-#include <stdexcept>
-%}
-
-// exported class
-
-namespace std {
-    
-    template<class T> class list {
-        %typemap(in) list<T> (std::list<T>* v) {
-            if (SWIG_ConvertPtr($input,(void **) &v, 
-                                $&1_descriptor,1) != -1) {
-                $1 = *v;
-            } else if (SvROK($input)) {
-                AV *av = (AV *)SvRV($input);
-                if (SvTYPE(av) != SVt_PVAV)
-                    SWIG_croak("Type error in argument $argnum of $symname. "
-                               "Expected an array of " #T);
-                SV **tv;
-                I32 len = av_len(av) + 1;
-                T* obj;
-                for (int i=0; i<len; i++) {
-                    tv = av_fetch(av, i, 0);
-                    if (SWIG_ConvertPtr(*tv, (void **)&obj, 
-                                        $descriptor(T *),0) != -1) {
-                        $1.push_back(*obj);
-                    } else {
-                        SWIG_croak("Type error in argument $argnum of "
-                                   "$symname. "
-                                   "Expected an array of " #T);
-                    }
-                }
-            } else {
-                SWIG_croak("Type error in argument $argnum of $symname. "
-                           "Expected an array of " #T);
-            }
-        }
-        %typemap(in) const list<T>& (std::list<T> temp,
-                                       std::list<T>* v),
-                     const list<T>* (std::list<T> temp,
-                                       std::list<T>* v) {
-            if (SWIG_ConvertPtr($input,(void **) &v, 
-                                $1_descriptor,1) != -1) {
-                $1 = v;
-            } else if (SvROK($input)) {
-                AV *av = (AV *)SvRV($input);
-                if (SvTYPE(av) != SVt_PVAV)
-                    SWIG_croak("Type error in argument $argnum of $symname. "
-                               "Expected an array of " #T);
-                SV **tv;
-                I32 len = av_len(av) + 1;
-                T* obj;
-                for (int i=0; i<len; i++) {
-                    tv = av_fetch(av, i, 0);
-                    if (SWIG_ConvertPtr(*tv, (void **)&obj, 
-                                        $descriptor(T *),0) != -1) {
-                        temp.push_back(*obj);
-                    } else {
-                        SWIG_croak("Type error in argument $argnum of "
-                                   "$symname. "
-                                   "Expected an array of " #T);
-                    }
-                }
-                $1 = &temp;
-            } else {
-                SWIG_croak("Type error in argument $argnum of $symname. "
-                           "Expected an array of " #T);
-            }
-        }
-        %typemap(out) list<T> {
-	    std::list<T>::const_iterator i;
-            unsigned int j;
-            int len = $1.size();
-            SV **svs = new SV*[len];
-            for (i=$1.begin(), j=0; i!=$1.end(); i++, j++) {
-                T* ptr = new T(*i);
-                svs[j] = sv_newmortal();
-                SWIG_MakePtr(svs[j], (void*) ptr, 
-                             $descriptor(T *), $shadow|$owner);
-            }
-            AV *myav = av_make(len, svs);
-            delete[] svs;
-            $result = newRV_noinc((SV*) myav);
-            sv_2mortal($result);
-            argvi++;
-        }
-        %typecheck(SWIG_TYPECHECK_LIST) list<T> {
-            {
-                /* wrapped list? */
-                std::list<T >* v;
-                if (SWIG_ConvertPtr($input,(void **) &v, 
-                                    $1_&descriptor,0) != -1) {
-                    $1 = 1;
-                } else if (SvROK($input)) {
-                    /* native sequence? */
-                    AV *av = (AV *)SvRV($input);
-                    if (SvTYPE(av) == SVt_PVAV) {
-                        SV **tv;
-                        I32 len = av_len(av) + 1;
-                        if (len == 0) {
-                            /* an empty sequence can be of any type */
-                            $1 = 1;
-                        } else {
-                            /* check the first element only */
-                            T* obj;
-                            tv = av_fetch(av, 0, 0);
-                            if (SWIG_ConvertPtr(*tv, (void **)&obj, 
-                                                $descriptor(T *),0) != -1)
-                                $1 = 1;
-                            else
-                                $1 = 0;
-                        }
-                    }
-                } else {
-                    $1 = 0;
-                }
-            }
-        }
-        %typecheck(SWIG_TYPECHECK_LIST) const list<T>&,
-                                          const list<T>* {
-            {
-                /* wrapped list? */
-                std::list<T >* v;
-                if (SWIG_ConvertPtr($input,(void **) &v, 
-                                    $1_descriptor,0) != -1) {
-                    $1 = 1;
-                } else if (SvROK($input)) {
-                    /* native sequence? */
-                    AV *av = (AV *)SvRV($input);
-                    if (SvTYPE(av) == SVt_PVAV) {
-                        SV **tv;
-                        I32 len = av_len(av) + 1;
-                        if (len == 0) {
-                            /* an empty sequence can be of any type */
-                            $1 = 1;
-                        } else {
-                            /* check the first element only */
-                            T* obj;
-                            tv = av_fetch(av, 0, 0);
-                            if (SWIG_ConvertPtr(*tv, (void **)&obj, 
-                                                $descriptor(T *),0) != -1)
-                                $1 = 1;
-                            else
-                                $1 = 0;
-                        }
-                    }
-                } else {
-                    $1 = 0;
-                }
-            }
-        }
-      public:
-        typedef size_t size_type;
-        typedef T value_type;
-        typedef const value_type& const_reference;
-
-        list();
-        list(const list<T> &);
-
-        unsigned int size() const;
-        bool empty() const;
-        void clear();
-        %rename(push) push_back;
-        void push_back(const T& x);
-    };
-
-
-    // specializations for built-ins
-
-    %define specialize_std_list(T,CHECK_T,TO_T,FROM_T)
-    template<> class list<T> {
-        %typemap(in) list<T> (std::list<T>* v) {
-            if (SWIG_ConvertPtr($input,(void **) &v, 
-                                $&1_descriptor,1) != -1){
-                $1 = *v;
-            } else if (SvROK($input)) {
-                AV *av = (AV *)SvRV($input);
-                if (SvTYPE(av) != SVt_PVAV)
-                    SWIG_croak("Type error in argument $argnum of $symname. "
-                               "Expected an array of " #T);
-                SV **tv;
-                I32 len = av_len(av) + 1;
-                for (int i=0; i<len; i++) {
-                    tv = av_fetch(av, i, 0);
-                    if (CHECK_T(*tv)) {
-                        $1.push_back(TO_T(*tv));
-                    } else {
-                        SWIG_croak("Type error in argument $argnum of "
-                                   "$symname. "
-                                   "Expected an array of " #T);
-                    }
-                }
-            } else {
-                SWIG_croak("Type error in argument $argnum of $symname. "
-                           "Expected an array of " #T);
-            }
-        }
-        %typemap(in) const list<T>& (std::list<T> temp,
-                                       std::list<T>* v),
-                     const list<T>* (std::list<T> temp,
-                                       std::list<T>* v) {
-            if (SWIG_ConvertPtr($input,(void **) &v, 
-                                $1_descriptor,1) != -1) {
-                $1 = v;
-            } else if (SvROK($input)) {
-                AV *av = (AV *)SvRV($input);
-                if (SvTYPE(av) != SVt_PVAV)
-                    SWIG_croak("Type error in argument $argnum of $symname. "
-                               "Expected an array of " #T);
-                SV **tv;
-                I32 len = av_len(av) + 1;
-                T* obj;
-                for (int i=0; i<len; i++) {
-                    tv = av_fetch(av, i, 0);
-                    if (CHECK_T(*tv)) {
-                        temp.push_back(TO_T(*tv));
-                    } else {
-                        SWIG_croak("Type error in argument $argnum of "
-                                   "$symname. "
-                                   "Expected an array of " #T);
-                    }
-                }
-                $1 = &temp;
-            } else {
-                SWIG_croak("Type error in argument $argnum of $symname. "
-                           "Expected an array of " #T);
-            }
-        }
-        %typemap(out) list<T> {
-	    std::list<T>::const_iterator i;
-            unsigned int j;
-            int len = $1.size();
-            SV **svs = new SV*[len];
-            for (i=$1.begin(), j=0; i!=$1.end(); i++, j++) {
-                svs[j] = sv_newmortal();
-                FROM_T(svs[j], *i);
-            }
-            AV *myav = av_make(len, svs);
-            delete[] svs;
-            $result = newRV_noinc((SV*) myav);
-            sv_2mortal($result);
-            argvi++;
-        }
-        %typecheck(SWIG_TYPECHECK_LIST) list<T> {
-            {
-                /* wrapped list? */
-                std::list<T >* v;
-                if (SWIG_ConvertPtr($input,(void **) &v, 
-                                    $1_&descriptor,0) != -1) {
-                    $1 = 1;
-                } else if (SvROK($input)) {
-                    /* native sequence? */
-                    AV *av = (AV *)SvRV($input);
-                    if (SvTYPE(av) == SVt_PVAV) {
-                        SV **tv;
-                        I32 len = av_len(av) + 1;
-                        if (len == 0) {
-                            /* an empty sequence can be of any type */
-                            $1 = 1;
-                        } else {
-                            /* check the first element only */
-                            tv = av_fetch(av, 0, 0);
-                            if (CHECK_T(*tv))
-                                $1 = 1;
-                            else
-                                $1 = 0;
-                        }
-                    }
-                } else {
-                    $1 = 0;
-                }
-            }
-        }
-        %typecheck(SWIG_TYPECHECK_LIST) const list<T>&,
-                                          const list<T>* {
-            {
-                /* wrapped list? */
-                std::list<T >* v;
-                if (SWIG_ConvertPtr($input,(void **) &v, 
-                                    $1_descriptor,0) != -1) {
-                    $1 = 1;
-                } else if (SvROK($input)) {
-                    /* native sequence? */
-                    AV *av = (AV *)SvRV($input);
-                    if (SvTYPE(av) == SVt_PVAV) {
-                        SV **tv;
-                        I32 len = av_len(av) + 1;
-                        if (len == 0) {
-                            /* an empty sequence can be of any type */
-                            $1 = 1;
-                        } else {
-                            /* check the first element only */
-                            tv = av_fetch(av, 0, 0);
-                            if (CHECK_T(*tv))
-                                $1 = 1;
-                            else
-                                $1 = 0;
-                        }
-                    }
-                } else {
-                    $1 = 0;
-                }
-            }
-        }
-      public:
-        typedef size_t size_type;
-        typedef T value_type;
-        typedef const value_type& const_reference;
-
-        list();
-        list(const list<T> &);
-
-        unsigned int size() const;
-        bool empty() const;
-        void clear();
-        %rename(push) push_back;
-        void push_back(T x);
-    };
-    %enddef
-
-    specialize_std_list(bool,SvIOK,SvIVX,sv_setiv);
-    specialize_std_list(char,SvIOK,SvIVX,sv_setiv);
-    specialize_std_list(int,SvIOK,SvIVX,sv_setiv);
-    specialize_std_list(short,SvIOK,SvIVX,sv_setiv);
-    specialize_std_list(long,SvIOK,SvIVX,sv_setiv);
-    specialize_std_list(unsigned char,SvIOK,SvIVX,sv_setiv);
-    specialize_std_list(unsigned int,SvIOK,SvIVX,sv_setiv);
-    specialize_std_list(unsigned short,SvIOK,SvIVX,sv_setiv);
-    specialize_std_list(unsigned long,SvIOK,SvIVX,sv_setiv);
-    specialize_std_list(float,SvNIOK,SwigSvToNumber,sv_setnv);
-    specialize_std_list(double,SvNIOK,SwigSvToNumber,sv_setnv);
-    specialize_std_list(std::string,SvPOK,SvPVX,SwigSvFromString);
-
-}
-
diff --git a/share/swig/2.0.11/perl5/std_vector.i b/share/swig/2.0.11/perl5/std_vector.i
deleted file mode 100644
index a3998ff..0000000
--- a/share/swig/2.0.11/perl5/std_vector.i
+++ /dev/null
@@ -1,577 +0,0 @@
-/* -----------------------------------------------------------------------------
- * std_vector.i
- *
- * SWIG typemaps for std::vector types
- * ----------------------------------------------------------------------------- */
-
-%include <std_common.i>
-
-// ------------------------------------------------------------------------
-// std::vector
-// 
-// The aim of all that follows would be to integrate std::vector with 
-// Perl as much as possible, namely, to allow the user to pass and 
-// be returned Perl arrays.
-// const declarations are used to guess the intent of the function being
-// exported; therefore, the following rationale is applied:
-// 
-//   -- f(std::vector<T>), f(const std::vector<T>&), f(const std::vector<T>*):
-//      the parameter being read-only, either a Perl sequence or a
-//      previously wrapped std::vector<T> can be passed.
-//   -- f(std::vector<T>&), f(std::vector<T>*):
-//      the parameter must be modified; therefore, only a wrapped std::vector
-//      can be passed.
-//   -- std::vector<T> f():
-//      the vector is returned by copy; therefore, a Perl sequence of T:s 
-//      is returned which is most easily used in other Perl functions
-//   -- std::vector<T>& f(), std::vector<T>* f(), const std::vector<T>& f(),
-//      const std::vector<T>* f():
-//      the vector is returned by reference; therefore, a wrapped std::vector
-//      is returned
-// ------------------------------------------------------------------------
-
-%{
-#include <vector>
-#include <algorithm>
-#include <stdexcept>
-%}
-
-// exported class
-
-namespace std {
-    
-    template<class T> class vector {
-        %typemap(in) vector<T> (std::vector<T>* v) {
-            if (SWIG_ConvertPtr($input,(void **) &v, 
-                                $&1_descriptor,1) != -1) {
-                $1 = *v;
-            } else if (SvROK($input)) {
-                AV *av = (AV *)SvRV($input);
-                if (SvTYPE(av) != SVt_PVAV)
-                    SWIG_croak("Type error in argument $argnum of $symname. "
-                               "Expected an array of " #T);
-                SV **tv;
-                I32 len = av_len(av) + 1;
-                T* obj;
-                for (int i=0; i<len; i++) {
-                    tv = av_fetch(av, i, 0);
-                    if (SWIG_ConvertPtr(*tv, (void **)&obj, 
-                                        $descriptor(T *),0) != -1) {
-                        $1.push_back(*obj);
-                    } else {
-                        SWIG_croak("Type error in argument $argnum of "
-                                   "$symname. "
-                                   "Expected an array of " #T);
-                    }
-                }
-            } else {
-                SWIG_croak("Type error in argument $argnum of $symname. "
-                           "Expected an array of " #T);
-            }
-        }
-        %typemap(in) const vector<T>& (std::vector<T> temp,
-                                       std::vector<T>* v),
-                     const vector<T>* (std::vector<T> temp,
-                                       std::vector<T>* v) {
-            if (SWIG_ConvertPtr($input,(void **) &v, 
-                                $1_descriptor,1) != -1) {
-                $1 = v;
-            } else if (SvROK($input)) {
-                AV *av = (AV *)SvRV($input);
-                if (SvTYPE(av) != SVt_PVAV)
-                    SWIG_croak("Type error in argument $argnum of $symname. "
-                               "Expected an array of " #T);
-                SV **tv;
-                I32 len = av_len(av) + 1;
-                T* obj;
-                for (int i=0; i<len; i++) {
-                    tv = av_fetch(av, i, 0);
-                    if (SWIG_ConvertPtr(*tv, (void **)&obj, 
-                                        $descriptor(T *),0) != -1) {
-                        temp.push_back(*obj);
-                    } else {
-                        SWIG_croak("Type error in argument $argnum of "
-                                   "$symname. "
-                                   "Expected an array of " #T);
-                    }
-                }
-                $1 = &temp;
-            } else {
-                SWIG_croak("Type error in argument $argnum of $symname. "
-                           "Expected an array of " #T);
-            }
-        }
-        %typemap(out) vector<T> {
-            size_t len = $1.size();
-            SV **svs = new SV*[len];
-            for (size_t i=0; i<len; i++) {
-                T* ptr = new T($1[i]);
-                svs[i] = sv_newmortal();
-                SWIG_MakePtr(svs[i], (void*) ptr, 
-                             $descriptor(T *), $shadow|$owner);
-            }
-            AV *myav = av_make(len, svs);
-            delete[] svs;
-            $result = newRV_noinc((SV*) myav);
-            sv_2mortal($result);
-            argvi++;
-        }
-        %typecheck(SWIG_TYPECHECK_VECTOR) vector<T> {
-            {
-                /* wrapped vector? */
-                std::vector<T >* v;
-                if (SWIG_ConvertPtr($input,(void **) &v, 
-                                    $&1_descriptor,0) != -1) {
-                    $1 = 1;
-                } else if (SvROK($input)) {
-                    /* native sequence? */
-                    AV *av = (AV *)SvRV($input);
-                    if (SvTYPE(av) == SVt_PVAV) {
-                        I32 len = av_len(av) + 1;
-                        if (len == 0) {
-                            /* an empty sequence can be of any type */
-                            $1 = 1;
-                        } else {
-                            /* check the first element only */
-                            T* obj;
-                            SV **tv = av_fetch(av, 0, 0);
-                            if (SWIG_ConvertPtr(*tv, (void **)&obj, 
-                                                $descriptor(T *),0) != -1)
-                                $1 = 1;
-                            else
-                                $1 = 0;
-                        }
-                    }
-                } else {
-                    $1 = 0;
-                }
-            }
-        }
-        %typecheck(SWIG_TYPECHECK_VECTOR) const vector<T>&,
-                                          const vector<T>* {
-            {
-                /* wrapped vector? */
-                std::vector<T >* v;
-                if (SWIG_ConvertPtr($input,(void **) &v, 
-                                    $1_descriptor,0) != -1) {
-                    $1 = 1;
-                } else if (SvROK($input)) {
-                    /* native sequence? */
-                    AV *av = (AV *)SvRV($input);
-                    if (SvTYPE(av) == SVt_PVAV) {
-                        I32 len = av_len(av) + 1;
-                        if (len == 0) {
-                            /* an empty sequence can be of any type */
-                            $1 = 1;
-                        } else {
-                            /* check the first element only */
-                            T* obj;
-                            SV **tv = av_fetch(av, 0, 0);
-                            if (SWIG_ConvertPtr(*tv, (void **)&obj, 
-                                                $descriptor(T *),0) != -1)
-                                $1 = 1;
-                            else
-                                $1 = 0;
-                        }
-                    }
-                } else {
-                    $1 = 0;
-                }
-            }
-        }
-      public:
-        typedef size_t size_type;
-        typedef T value_type;
-        typedef const value_type& const_reference;
-        vector(unsigned int size = 0);
-        vector(unsigned int size, const T& value);
-        vector(const vector<T> &);
-
-        unsigned int size() const;
-        bool empty() const;
-        void clear();
-        %rename(push) push_back;
-        void push_back(const T& x);
-        %extend {
-            T pop() throw (std::out_of_range) {
-                if (self->size() == 0)
-                    throw std::out_of_range("pop from empty vector");
-                T x = self->back();
-                self->pop_back();
-                return x;
-            }
-            T& 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 T& x) throw (std::out_of_range) {
-                int size = int(self->size());
-                if (i>=0 && i<size)
-                    (*self)[i] = x;
-                else
-                    throw std::out_of_range("vector index out of range");
-            }
-        }
-    };
-
-    // specializations for pointers
-    template<class T> class vector<T*> {
-        %typemap(in) vector<T*> (std::vector<T*>* v) {
-	    int res = SWIG_ConvertPtr($input,(void **) &v, $&1_descriptor,0);
-            if (SWIG_IsOK(res)){
-                $1 = *v;
-            } else if (SvROK($input)) {
-                AV *av = (AV *)SvRV($input);
-                if (SvTYPE(av) != SVt_PVAV)
-                    SWIG_croak("Type error in argument $argnum of $symname. "
-                               "Expected an array of " #T);
-                I32 len = av_len(av) + 1;
-                for (int i=0; i<len; i++) {
-		    void *v;
-		    SV **tv = av_fetch(av, i, 0);
-		    int res = SWIG_ConvertPtr(*tv, &v, $descriptor(T *),0);
-                    if (SWIG_IsOK(res)) {
-                        $1.push_back(%static_cast(v, T *));
-                    } else {
-                        SWIG_croak("Type error in argument $argnum of "
-                                   "$symname. "
-                                   "Expected an array of " #T);
-                    }
-                }
-            } else {
-                SWIG_croak("Type error in argument $argnum of $symname. "
-                           "Expected an array of " #T);
-            }
-        }
-        %typemap(in) const vector<T *>& (std::vector<T *> temp,std::vector<T *>* v),
-                     const vector<T *>* (std::vector<T *> temp,std::vector<T *>* v) {
-	    int res = SWIG_ConvertPtr($input,(void **) &v, $1_descriptor,0);
-            if (SWIG_IsOK(res)) {
-                $1 = v;
-            } else if (SvROK($input)) {
-                AV *av = (AV *)SvRV($input);
-                if (SvTYPE(av) != SVt_PVAV)
-                    SWIG_croak("Type error in argument $argnum of $symname. "
-                               "Expected an array of " #T);
-                I32 len = av_len(av) + 1;
-                for (int i=0; i<len; i++) {
-		    void *v;
-		    SV **tv = av_fetch(av, i, 0);
-		    int res = SWIG_ConvertPtr(*tv, &v, $descriptor(T *),0);
-                    if (SWIG_IsOK(res)) {
-                        temp.push_back(%static_cast(v, T *));
-                    } else {
-                        SWIG_croak("Type error in argument $argnum of "
-                                   "$symname. "
-                                   "Expected an array of " #T);
-                    }
-                }
-                $1 = &temp;
-            } else {
-                SWIG_croak("Type error in argument $argnum of $symname. "
-                           "Expected an array of " #T);
-            }
-        }
-        %typemap(out) vector<T *> {
-            size_t len = $1.size();
-            SV **svs = new SV*[len];
-            for (size_t i=0; i<len; i++) {
-                T *x = (($1_type &)$1)[i];
-                svs[i] = sv_newmortal();
-		sv_setsv(svs[i], SWIG_NewPointerObj(x, $descriptor(T *), 0));
-            }
-            AV *myav = av_make(len, svs);
-            delete[] svs;
-            $result = newRV_noinc((SV*) myav);
-            sv_2mortal($result);
-            argvi++;
-        }
-        %typecheck(SWIG_TYPECHECK_VECTOR) vector<T *> {
-            {
-                /* wrapped vector? */
-                std::vector<T *>* v;
-		int res = SWIG_ConvertPtr($input,(void **) &v, $&1_descriptor,0);
-                if (SWIG_IsOK(res)) {
-                    $1 = 1;
-                } else if (SvROK($input)) {
-                    /* native sequence? */
-                    AV *av = (AV *)SvRV($input);
-                    if (SvTYPE(av) == SVt_PVAV) {
-                        I32 len = av_len(av) + 1;
-                        if (len == 0) {
-                            /* an empty sequence can be of any type */
-                            $1 = 1;
-                        } else {
-                            /* check the first element only */
-			    void *v;
-			    SV **tv = av_fetch(av, 0, 0);
-			    int res = SWIG_ConvertPtr(*tv, &v, $descriptor(T *),0);
-                            if (SWIG_IsOK(res))
-                                $1 = 1;
-                            else
-                                $1 = 0;
-                        }
-                    }
-                } else {
-                    $1 = 0;
-                }
-            }
-        }
-        %typecheck(SWIG_TYPECHECK_VECTOR) const vector<T *>&,const vector<T *>* {
-            {
-                /* wrapped vector? */
-                std::vector<T *> *v;
-		int res = SWIG_ConvertPtr($input,%as_voidptrptr(&v), $1_descriptor,0);
-                if (SWIG_IsOK(res)) {
-                    $1 = 1;
-                } else if (SvROK($input)) {
-                    /* native sequence? */
-                    AV *av = (AV *)SvRV($input);
-                    if (SvTYPE(av) == SVt_PVAV) {
-                        I32 len = av_len(av) + 1;
-                        if (len == 0) {
-                            /* an empty sequence can be of any type */
-                            $1 = 1;
-                        } else {
-                            /* check the first element only */
-			    void *v;
-			    SV **tv = av_fetch(av, 0, 0);
-			    int res = SWIG_ConvertPtr(*tv, &v, $descriptor(T *),0);
-                            if (SWIG_IsOK(res))
-                                $1 = 1;
-                            else
-                                $1 = 0;
-                        }
-                    }
-                } else {
-                    $1 = 0;
-                }
-            }
-        }
-      public:
-        typedef size_t size_type;
-        typedef T value_type;
-        typedef const value_type& const_reference;
-        vector(unsigned int size = 0);
-        vector(unsigned int size, T *value);
-        vector(const vector<T *> &);
-
-        unsigned int size() const;
-        bool empty() const;
-        void clear();
-        %rename(push) push_back;
-        void push_back(T *x);
-        %extend {
-            T *pop() throw (std::out_of_range) {
-                if (self->size() == 0)
-                    throw std::out_of_range("pop from empty vector");
-                T *x = self->back();
-                self->pop_back();
-                return x;
-            }
-            T *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, T *x) throw (std::out_of_range) {
-                int size = int(self->size());
-                if (i>=0 && i<size)
-                    (*self)[i] = x;
-                else
-                    throw std::out_of_range("vector index out of range");
-            }
-        }
-    };
-
-
-    // specializations for built-ins
-
-    %define specialize_std_vector(T,CHECK_T,TO_T,FROM_T)
-    template<> class vector<T> {
-        %typemap(in) vector<T> (std::vector<T>* v) {
-            if (SWIG_ConvertPtr($input,(void **) &v, 
-                                $&1_descriptor,1) != -1){
-                $1 = *v;
-            } else if (SvROK($input)) {
-                AV *av = (AV *)SvRV($input);
-                if (SvTYPE(av) != SVt_PVAV)
-                    SWIG_croak("Type error in argument $argnum of $symname. "
-                               "Expected an array of " #T);
-                SV **tv;
-                I32 len = av_len(av) + 1;
-                for (int i=0; i<len; i++) {
-                    tv = av_fetch(av, i, 0);
-                    if (CHECK_T(*tv)) {
-                        $1.push_back((T)TO_T(*tv));
-                    } else {
-                        SWIG_croak("Type error in argument $argnum of "
-                                   "$symname. "
-                                   "Expected an array of " #T);
-                    }
-                }
-            } else {
-                SWIG_croak("Type error in argument $argnum of $symname. "
-                           "Expected an array of " #T);
-            }
-        }
-        %typemap(in) const vector<T>& (std::vector<T> temp,
-                                       std::vector<T>* v),
-                     const vector<T>* (std::vector<T> temp,
-                                       std::vector<T>* v) {
-            if (SWIG_ConvertPtr($input,(void **) &v, 
-                                $1_descriptor,1) != -1) {
-                $1 = v;
-            } else if (SvROK($input)) {
-                AV *av = (AV *)SvRV($input);
-                if (SvTYPE(av) != SVt_PVAV)
-                    SWIG_croak("Type error in argument $argnum of $symname. "
-                               "Expected an array of " #T);
-                SV **tv;
-                I32 len = av_len(av) + 1;
-                for (int i=0; i<len; i++) {
-                    tv = av_fetch(av, i, 0);
-                    if (CHECK_T(*tv)) {
-                        temp.push_back((T)TO_T(*tv));
-                    } else {
-                        SWIG_croak("Type error in argument $argnum of "
-                                   "$symname. "
-                                   "Expected an array of " #T);
-                    }
-                }
-                $1 = &temp;
-            } else {
-                SWIG_croak("Type error in argument $argnum of $symname. "
-                           "Expected an array of " #T);
-            }
-        }
-        %typemap(out) vector<T> {
-            size_t len = $1.size();
-            SV **svs = new SV*[len];
-            for (size_t i=0; i<len; i++) {
-                svs[i] = sv_newmortal();
-                FROM_T(svs[i], $1[i]);
-            }
-            AV *myav = av_make(len, svs);
-            delete[] svs;
-            $result = newRV_noinc((SV*) myav);
-            sv_2mortal($result);
-            argvi++;
-        }
-        %typecheck(SWIG_TYPECHECK_VECTOR) vector<T> {
-            {
-                /* wrapped vector? */
-                std::vector<T >* v;
-                if (SWIG_ConvertPtr($input,(void **) &v, 
-                                    $&1_descriptor,0) != -1) {
-                    $1 = 1;
-                } else if (SvROK($input)) {
-                    /* native sequence? */
-                    AV *av = (AV *)SvRV($input);
-                    if (SvTYPE(av) == SVt_PVAV) {
-                        I32 len = av_len(av) + 1;
-                        if (len == 0) {
-                            /* an empty sequence can be of any type */
-                            $1 = 1;
-                        } else {
-                            /* check the first element only */
-                            SV **tv = av_fetch(av, 0, 0);
-                            if (CHECK_T(*tv))
-                                $1 = 1;
-                            else
-                                $1 = 0;
-                        }
-                    }
-                } else {
-                    $1 = 0;
-                }
-            }
-        }
-        %typecheck(SWIG_TYPECHECK_VECTOR) const vector<T>&,
-                                          const vector<T>* {
-            {
-                /* wrapped vector? */
-                std::vector<T >* v;
-                if (SWIG_ConvertPtr($input,(void **) &v, 
-                                    $1_descriptor,0) != -1) {
-                    $1 = 1;
-                } else if (SvROK($input)) {
-                    /* native sequence? */
-                    AV *av = (AV *)SvRV($input);
-                    if (SvTYPE(av) == SVt_PVAV) {
-                        I32 len = av_len(av) + 1;
-                        if (len == 0) {
-                            /* an empty sequence can be of any type */
-                            $1 = 1;
-                        } else {
-                            /* check the first element only */
-                            SV **tv = av_fetch(av, 0, 0);
-                            if (CHECK_T(*tv))
-                                $1 = 1;
-                            else
-                                $1 = 0;
-                        }
-                    }
-                } else {
-                    $1 = 0;
-                }
-            }
-        }
-      public:
-        typedef size_t size_type;
-        typedef T value_type;
-        typedef const value_type& const_reference;
-        vector(unsigned int size = 0);
-        vector(unsigned int size, T value);
-        vector(const vector<T> &);
-
-        unsigned int size() const;
-        bool empty() const;
-        void clear();
-        %rename(push) push_back;
-        void push_back(T x);
-        %extend {
-            T pop() throw (std::out_of_range) {
-                if (self->size() == 0)
-                    throw std::out_of_range("pop from empty vector");
-                T x = self->back();
-                self->pop_back();
-                return x;
-            }
-            T 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, T x) throw (std::out_of_range) {
-                int size = int(self->size());
-                if (i>=0 && i<size)
-                    (*self)[i] = x;
-                else
-                    throw std::out_of_range("vector index out of range");
-            }
-        }
-    };
-    %enddef
-
-    specialize_std_vector(bool,SvIOK,SvIVX,sv_setiv);
-    specialize_std_vector(char,SvIOK,SvIVX,sv_setiv);
-    specialize_std_vector(int,SvIOK,SvIVX,sv_setiv);
-    specialize_std_vector(short,SvIOK,SvIVX,sv_setiv);
-    specialize_std_vector(long,SvIOK,SvIVX,sv_setiv);
-    specialize_std_vector(unsigned char,SvIOK,SvIVX,sv_setiv);
-    specialize_std_vector(unsigned int,SvIOK,SvIVX,sv_setiv);
-    specialize_std_vector(unsigned short,SvIOK,SvIVX,sv_setiv);
-    specialize_std_vector(unsigned long,SvIOK,SvIVX,sv_setiv);
-    specialize_std_vector(float,SvNIOK,SwigSvToNumber,sv_setnv);
-    specialize_std_vector(double,SvNIOK,SwigSvToNumber,sv_setnv);
-    specialize_std_vector(std::string,SvPOK,SwigSvToString,SwigSvFromString);
-}
-
diff --git a/share/swig/2.0.11/php/const.i b/share/swig/2.0.11/php/const.i
deleted file mode 100644
index 78f3a8a..0000000
--- a/share/swig/2.0.11/php/const.i
+++ /dev/null
@@ -1,50 +0,0 @@
-/* -----------------------------------------------------------------------------
- * const.i
- *
- * Typemaps for constants
- * ----------------------------------------------------------------------------- */
-
-%typemap(consttab) int,
-                   unsigned int,
-                   short,
-                   unsigned short,
-                   long,
-                   unsigned long,
-                   unsigned char,
-                   signed char,
-                   bool,
-                   enum SWIGTYPE
-  "SWIG_LONG_CONSTANT($symname, $value);";
-
-%typemap(consttab) float,
-                   double
-  "SWIG_DOUBLE_CONSTANT($symname, $value);";
-
-%typemap(consttab) char
-  "SWIG_CHAR_CONSTANT($symname, $value);";
-
-%typemap(consttab) char *,
-                   const char *,
-                   char [],
-                   const char []
-  "SWIG_STRING_CONSTANT($symname, $value);";
-
-%typemap(consttab) SWIGTYPE *,
-                   SWIGTYPE &,
-                   SWIGTYPE [] {
-  zval *z_var;
-  MAKE_STD_ZVAL(z_var);
-  SWIG_SetPointerZval(z_var, (void*)$value, $1_descriptor, 0);
-  zend_constant c;
-  c.value = *z_var;
-  zval_copy_ctor(&c.value);
-  size_t len = sizeof("$symname") - 1;
-  c.name = zend_strndup("$symname", len);
-  c.name_len = len+1;
-  c.flags = CONST_CS | CONST_PERSISTENT;
-  c.module_number = module_number;
-  zend_register_constant( &c TSRMLS_CC );
-}
-
-/* Handled as a global variable. */
-%typemap(consttab) SWIGTYPE (CLASS::*) "";
diff --git a/share/swig/2.0.11/php/director.swg b/share/swig/2.0.11/php/director.swg
deleted file mode 100644
index 90f6a74..0000000
--- a/share/swig/2.0.11/php/director.swg
+++ /dev/null
@@ -1,197 +0,0 @@
-/* -----------------------------------------------------------------------------
- * director.swg
- *
- * This file contains support for director classes that proxy
- * method calls from C++ to PHP extensions.
- * ----------------------------------------------------------------------------- */
-
-#ifndef SWIG_DIRECTOR_PHP_HEADER_
-#define SWIG_DIRECTOR_PHP_HEADER_
-
-#ifdef __cplusplus
-
-#include <string>
-#include <map>
-
-/*
-  Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
-  'Swig' namespace. This could be useful for multi-modules projects.
-*/
-#ifdef SWIG_DIRECTOR_STATIC
-/* Force anonymous (static) namespace */
-#define Swig
-#endif
-
-namespace Swig {
-  /* memory handler */
-  struct GCItem
-  {
-    virtual ~GCItem() {}
-
-    virtual int get_own() const
-    {
-      return 0;
-    }
-  };
-
-  struct GCItem_var
-  {
-    GCItem_var(GCItem *item = 0) : _item(item)
-    {
-    }
-
-    GCItem_var& operator=(GCItem *item)
-    {
-      GCItem *tmp = _item;
-      _item = item;
-      delete tmp;
-      return *this;
-    }
-
-    ~GCItem_var()
-    {
-      delete _item;
-    }
-
-    GCItem * operator->() const
-    {
-      return _item;
-    }
-
-    private:
-    GCItem *_item;
-  };
-
-  struct GCItem_Object : GCItem
-  {
-    GCItem_Object(int own) : _own(own)
-    {
-    }
-
-    virtual ~GCItem_Object()
-    {
-    }
-
-    int get_own() const
-    {
-      return _own;
-    }
-
-    private:
-    int _own;
-  };
-
-  template <typename Type>
-  struct GCItem_T : GCItem
-  {
-    GCItem_T(Type *ptr) : _ptr(ptr)
-    {
-    }
-
-    virtual ~GCItem_T()
-    {
-      delete _ptr;
-    }
-
-    private:
-    Type *_ptr;
-  };
-
-  class Director {
-    protected:
-      zval *swig_self;
-      typedef std::map<void*, GCItem_var> swig_ownership_map;
-      mutable swig_ownership_map swig_owner;
-#ifdef ZTS
-      // Store the ZTS context so it's available when C++ calls back to PHP.
-      void *** swig_zts_ctx;
-#endif 
-    public:
-      Director(zval* self TSRMLS_DC) : swig_self(self) {
-        TSRMLS_SET_CTX(swig_zts_ctx);
-      }
-
-      bool swig_is_overridden_method(char *cname, char *lc_fname) {
-        TSRMLS_FETCH_FROM_CTX(swig_zts_ctx);
-        zend_class_entry **ce;
-        zend_function *mptr;
-        int name_len = strlen(lc_fname);
-        
-        if (zend_lookup_class(cname, strlen(cname), &ce TSRMLS_CC) != SUCCESS) {
-          return false;
-        }
-        if (zend_hash_find(&(*ce)->function_table, lc_fname, name_len + 1, (void**) &mptr) != SUCCESS) {
-          return false;
-        }
-        // common.scope points to the declaring class
-        return strcmp(mptr->common.scope->name, cname);
-      }
-
-      template <typename Type>
-      void swig_acquire_ownership(Type *vptr) const
-      {
-        if (vptr) {
-          swig_owner[vptr] = new GCItem_T<Type>(vptr);
-        }
-      }
-  };
-
-  /* base class for director exceptions */
-  class DirectorException {
-  protected:
-    std::string swig_msg;
-  public:
-    DirectorException(int code, const char *hdr, const char* msg TSRMLS_DC)
-      : swig_msg(hdr)
-    {
-      if (strlen(msg)) {
-        swig_msg += " ";
-        swig_msg += msg;
-      }
-      SWIG_ErrorCode() = code;
-      SWIG_ErrorMsg() = swig_msg.c_str();
-    }
-
-    static void raise(int code, const char *hdr, const char* msg TSRMLS_DC)
-    {
-      throw DirectorException(code, hdr, msg TSRMLS_CC);
-    }
-  };
-
-  /* attempt to call a pure virtual method via a director method */
-  class DirectorPureVirtualException : public Swig::DirectorException
-  {
-  public:
-    DirectorPureVirtualException(const char* msg TSRMLS_DC)
-      : DirectorException(E_ERROR, "SWIG director pure virtual method called", msg TSRMLS_CC)
-    {
-    }
-
-    static void raise(const char *msg TSRMLS_DC)
-    {
-      throw DirectorPureVirtualException(msg TSRMLS_CC);
-    }
-  };
-  /* any php exception that occurs during a director method call */
-  class DirectorMethodException : public Swig::DirectorException
-  {
-  public:
-    DirectorMethodException(const char* msg TSRMLS_DC)
-      : DirectorException(E_ERROR, "SWIG director method error", msg TSRMLS_CC)
-    {
-    }
-
-    static void raise(const char *msg TSRMLS_DC)
-    {
-      throw DirectorMethodException(msg TSRMLS_CC);
-    }
-  };
-}
-
-// DirectorMethodException() is documented to be callable with no parameters
-// so use a macro to insert TSRMLS_CC so any ZTS context gets passed.
-#define DirectorMethodException() DirectorMethodException("" TSRMLS_CC)
-
-#endif /* __cplusplus */
-
-#endif
diff --git a/share/swig/2.0.11/php/globalvar.i b/share/swig/2.0.11/php/globalvar.i
deleted file mode 100644
index 45fb022..0000000
--- a/share/swig/2.0.11/php/globalvar.i
+++ /dev/null
@@ -1,355 +0,0 @@
-/* -----------------------------------------------------------------------------
- * globalvar.i
- *
- * Global variables - add the variable to PHP
- * ----------------------------------------------------------------------------- */
-
-%typemap(varinit) char *,
-                  char []
-{
-  zval *z_var;
-  MAKE_STD_ZVAL(z_var);
-  z_var->type = IS_STRING;
-  if($1) {
-      z_var->value.str.val = estrdup($1);
-      z_var->value.str.len = strlen($1);
-  } else {
-      z_var->value.str.val = 0;
-      z_var->value.str.len = 0;
-  }
-  zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var, sizeof(zval *), NULL);
-}
-
-%typemap(varinit) int,
-	          unsigned int,
-                  unsigned short,
-                  short,
-                  unsigned short,
-                  long,
-                  unsigned long,
-                  signed char,
-                  unsigned char,
-                  enum SWIGTYPE
-{
-  zval *z_var;
-  MAKE_STD_ZVAL(z_var);
-  z_var->type = IS_LONG;
-  z_var->value.lval = $1;
-  zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var, sizeof(zval *), NULL);
-}
-
-%typemap(varinit) bool
-{
-  zval *z_var;
-  MAKE_STD_ZVAL(z_var);
-  z_var->type = IS_BOOL;
-  z_var->value.lval = ($1)?1:0;
-  zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var, sizeof(zval *), NULL);
-}
-
-%typemap(varinit) float, double
-{
-  zval *z_var;
-  MAKE_STD_ZVAL(z_var);
-  z_var->type = IS_DOUBLE;
-  z_var->value.dval = $1;
-  zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var,
-  sizeof(zval *), NULL);
-}
-
-%typemap(varinit) char
-{
-  zval *z_var;
-  char c[2];
-  MAKE_STD_ZVAL(z_var);
-  c[0] = $1;
-  c[1] = 0;
-  z_var->type = IS_STRING;
-  z_var->value.str.val = estrndup(c, 1);
-  z_var->value.str.len = 1;
-  zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var,
-  sizeof(zval *), NULL);
-}
-
-%typemap(varinit) SWIGTYPE *, SWIGTYPE []
-{
-  zval *z_var;
-  MAKE_STD_ZVAL(z_var);
-  SWIG_SetPointerZval(z_var, (void*)$1, $1_descriptor, 0);
-  zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var,
-  sizeof(zval *), NULL);
-}
-
-%typemap(varinit) SWIGTYPE, SWIGTYPE &
-{
-  zval *z_var;
-
-  MAKE_STD_ZVAL(z_var);
-  SWIG_SetPointerZval(z_var, (void*)&$1, $&1_descriptor, 0);
-  zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void*)&z_var,
-  sizeof(zval *), NULL);
-}
-
-%typemap(varinit) char [ANY]
-{
-  zval *z_var;
-  MAKE_STD_ZVAL(z_var);
-  z_var->type = IS_STRING;
-  if ($1) {
-    /* varinit char [ANY] */
-    ZVAL_STRINGL(z_var,(char*)$1, $1_dim0, 1);
-  }
-  zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void*)&z_var, sizeof(zval *), NULL);
-}
-
-%typemap(varinit, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
-{
-  void * p = emalloc(sizeof($1));
-  memcpy(p, &$1, sizeof($1));
-  zval * resource;
-  MAKE_STD_ZVAL(resource);
-  ZEND_REGISTER_RESOURCE(resource, p, swig_member_ptr);
-  zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void*)&resource, sizeof(zval *), NULL);
-}
-
-%typemap(varin) int, unsigned int, short, unsigned short, long, unsigned long, signed char, unsigned char,  enum SWIGTYPE
-{
-  zval **z_var;
-
-  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
-  convert_to_long_ex(z_var);
-  if ($1 != ($1_ltype)((*z_var)->value.lval)) {
-    $1 = Z_LVAL_PP(z_var);
-  }
-}
-
-%typemap(varin) bool
-{
-  zval **z_var;
-
-  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
-  convert_to_boolean_ex(z_var);
-  if ($1 != ($1_ltype)((*z_var)->value.lval)) {
-    $1 = Z_LVAL_PP(z_var);
-  }
-}
-
-%typemap(varin) double,float
-{
-  zval **z_var;
-
-  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
-  convert_to_double_ex(z_var);
-  if ($1 != ($1_ltype)((*z_var)->value.dval)) {
-    $1 = Z_DVAL_PP(z_var);
-  }
-}
-
-%typemap(varin) char
-{
-  zval **z_var;
-
-  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
-  convert_to_string_ex(z_var);
-  if ($1 != *((*z_var)->value.str.val)) {
-    $1 = *((*z_var)->value.str.val);
-  }
-}
-
-%typemap(varin) char *
-{
-  zval **z_var;
-  char *s1;
-
-  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
-  convert_to_string_ex(z_var);
-  s1 = Z_STRVAL_PP(z_var);
-  if ((s1 == NULL) || ($1 == NULL) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($1))) {
-    if (s1)
-      $1 = estrdup(s1);
-    else
-      $1 = NULL;
-  }
-}
-
-
-%typemap(varin) SWIGTYPE []
-{
-  zval **z_var;
-
-  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
-  if($1) {
-    SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, $owner);
-  }
-}
-
-%typemap(varin) char [ANY]
-{
- zval **z_var;
- char *s1;
-
- zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
- s1 = Z_STRVAL_PP(z_var);
- if((s1 == NULL) || ($1 == NULL) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($1))) {
-  if(s1)
-    strncpy($1, s1, $1_dim0);
- }
-}
-
-%typemap(varin) SWIGTYPE
-{
-  zval **z_var;
-  $&1_ltype _temp;
-
-  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
-  if (SWIG_ConvertPtr(*z_var, (void**)&_temp, $&1_descriptor, 0) < 0) {
-    SWIG_PHP_Error(E_ERROR,"Type error in value of $symname. Expected $&1_descriptor");
-  }
-
-  $1 = *($&1_ltype)_temp;
-
-}
-
-%typemap(varin) SWIGTYPE *, SWIGTYPE &
-{
-  zval **z_var;
-  $1_ltype _temp;
-
-  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
-  if (SWIG_ConvertPtr(*z_var, (void **)&_temp, $1_descriptor, 0) < 0) { 
-    SWIG_PHP_Error(E_ERROR,"Type error in value of $symname. Expected $&1_descriptor");
-  }
-
-  $1 = ($1_ltype)_temp;
-}
-
-%typemap(varin, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
-{
-  zval **z_var;
-
-  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
-  void * p = (void*)zend_fetch_resource(*z_var TSRMLS_CC, -1, SWIG_MEMBER_PTR, NULL, 1, swig_member_ptr);
-  memcpy(&$1, p, sizeof($1));
-}
-
-%typemap(varout) int,
-                 unsigned int,
-                 unsigned short,
-                 short,
-                 long,
-                 unsigned long,
-                 signed char,
-                 unsigned char,
-                 enum SWIGTYPE
-{
-  zval **z_var;
-  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
-  if($1 != ($1_ltype)((*z_var)->value.lval)) {
-    (*z_var)->value.lval = (long)$1;
-  }
-}
-
-//SAMFIX need to cast zval->type, what if zend-hash_find fails? etc?
-%typemap(varout) bool
-{
-  zval **z_var;
-  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
-  if($1 != ($1_ltype)((*z_var)->value.lval)) {
-    (*z_var)->value.lval = (long)$1;
-  }
-}
-
-%typemap(varout) double, float
-{
-  zval **z_var;
-  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
-  if($1 != ($1_ltype)((*z_var)->value.dval)) {
-    (*z_var)->value.dval = (double)$1;
-  }
-}
-
-%typemap(varout) char
-{
-  zval **z_var;
-  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
-  if($1 != *((*z_var)->value.str.val)) {
-    char c[2];
-    efree((*z_var)->value.str.val);
-    c[0] = $1;
-    c[1] = 0;
-    (*z_var)->value.str.val = estrdup(c);
-  }
-}
-
-%typemap(varout) char *
-{
-  zval **z_var;
-  char *s1;
-
-  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
-  s1 = Z_STRVAL_PP(z_var);
-  if((s1 == NULL) || ($1 == NULL) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($1) )) {
-    if(s1)
-      efree(s1);
-    if($1) {
-      (*z_var)->value.str.val = estrdup($1);
-      (*z_var)->value.str.len = strlen($1) +1;
-    } else {
-      (*z_var)->value.str.val = 0;
-      (*z_var)->value.str.len = 0;
-    }
- }
-}
-
-%typemap(varout) SWIGTYPE
-{
-  zval **z_var;
-
-  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
-  SWIG_SetPointerZval(*z_var, (void*)&$1, $&1_descriptor, 0);
-}
-
-%typemap(varout) SWIGTYPE []
-{
-  zval **z_var;
-
-  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
-  if($1) 
-    SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, 0);
-}
-
-%typemap(varout) char [ANY]
-{
-  zval **z_var;
-  char *s1;
-deliberate error cos this code looks bogus to me
-  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
-  s1 = Z_STRVAL_PP(z_var);
-  if((s1 == NULL) || zend_binary_strcmp(s1, strlen(s1), $1, strlen($1))) {
-    if($1) {
-      (*z_var)->value.str.val = estrdup($1);
-      (*z_var)->value.str.len = strlen($1)+1;
-    } else {
-      (*z_var)->value.str.val = 0;
-      (*z_var)->value.str.len = 0;
-    }
-  }
-}
-
-%typemap(varout) SWIGTYPE *, SWIGTYPE &
-{
-  zval **z_var;
-
-  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
-  SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, 0);
-}
-
-%typemap(varout, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
-{
-  void * p = emalloc(sizeof($1));
-  memcpy(p, &$1, sizeof($1));
-  zval * resource;
-  MAKE_STD_ZVAL(resource);
-  ZEND_REGISTER_RESOURCE(resource, p, swig_member_ptr);
-  zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void*)&resource, sizeof(zval *), NULL);
-}
diff --git a/share/swig/2.0.11/php/php.swg b/share/swig/2.0.11/php/php.swg
deleted file mode 100644
index f27e1fe..0000000
--- a/share/swig/2.0.11/php/php.swg
+++ /dev/null
@@ -1,501 +0,0 @@
-/* -----------------------------------------------------------------------------
- * php.swg
- *
- * PHP configuration file
- * ----------------------------------------------------------------------------- */
-
-%runtime "swigrun.swg"  // Common C API type-checking code
-%runtime "phprun.swg"	// PHP runtime functions
-
-%include <phpinit.swg> // PHP initialization routine.
-
-%include <globalvar.i>	// Global variables.
-%include <const.i>
-
-// use %init %{ "/*code goes here*/ " %}
-// or  %minit %{ "/* code goes here*/ " %} to
-// insert code in the PHP_MINIT_FUNCTION
-#define %minit %insert("init")
-
-// use %rinit %{ "/* code goes here*/ " %} to
-// insert code in the PHP_RINIT_FUNCTION
-#define %rinit %insert("rinit")
-
-// use %shutdown %{ " /*code goes here*/ " %} to
-// insert code in the PHP_MSHUTDOWN_FUNCTION
-#define %shutdown  %insert("shutdown")
-#define %mshutdown  %insert("shutdown")
-
-// use %rshutdown %{ " /*code goes here*/" %} to
-// insert code in the PHP_RSHUTDOWN_FUNCTION
-#define %rshutdown  %insert("rshutdown")
-
-/* Typemaps for input parameters by value */
-
-%include <utils.i>
-
-%pass_by_val(bool,CONVERT_BOOL_IN);
-
-%pass_by_val(size_t, CONVERT_INT_IN);
-
-%pass_by_val(enum SWIGTYPE, CONVERT_INT_IN);
-
-%pass_by_val(signed int, CONVERT_INT_IN);
-%pass_by_val(int,CONVERT_INT_IN);
-%pass_by_val(unsigned int,CONVERT_INT_IN);
-
-%pass_by_val(signed short, CONVERT_INT_IN);
-%pass_by_val(short,CONVERT_INT_IN);
-%pass_by_val(unsigned short, CONVERT_INT_IN);
-
-%pass_by_val(signed long, CONVERT_INT_IN);
-%pass_by_val(long, CONVERT_INT_IN);
-%pass_by_val(unsigned long, CONVERT_INT_IN);
-
-%pass_by_val(signed long long, CONVERT_LONG_LONG_IN);
-%pass_by_val(long long, CONVERT_LONG_LONG_IN);
-%pass_by_val(unsigned long long, CONVERT_UNSIGNED_LONG_LONG_IN);
-
-%pass_by_val(signed char, CONVERT_INT_IN);
-%pass_by_val(char, CONVERT_CHAR_IN);
-%pass_by_val(unsigned char, CONVERT_INT_IN);
-
-%pass_by_val(float, CONVERT_FLOAT_IN);
-
-%pass_by_val(double, CONVERT_FLOAT_IN);
-
-%pass_by_val(char *, CONVERT_STRING_IN);
-%typemap(in) char *& = const char *&;
-%typemap(directorout) char *& = const char *&;
-
-// char array can be in/out, though the passed string may not be big enough...
-// so we have to size it
-%typemap(in) char[ANY]
-{
-   convert_to_string_ex($input);
-   $1 = ($1_ltype) Z_STRVAL_PP($input);
-}
-
-%typemap(in) (char *STRING, int LENGTH), (char *STRING, size_t LENGTH) {
-   convert_to_string_ex($input);
-   $1 = ($1_ltype) Z_STRVAL_PP($input);
-   $2 = ($2_ltype) Z_STRLEN_PP($input);
-}
-
-/* Object passed by value. Convert to a pointer */
-%typemap(in) SWIGTYPE ($&1_ltype tmp)
-{
-	if(SWIG_ConvertPtr(*$input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL) {
-          SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
-	}
-	$1 = *tmp;
-}
-
-%typemap(directorout) SWIGTYPE ($&1_ltype tmp)
-{
-	if(SWIG_ConvertPtr(*$input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL) {
-          SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
-	}
-	$result = *tmp;
-}
-
-%typemap(in) SWIGTYPE *,
-	     SWIGTYPE []
-{
-	if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0) {
-            SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor");
-	}
-}
-
-%typemap(in) SWIGTYPE &
-{
-	if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0 || $1 == NULL) {
-	    SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor");
-	}
-}
-
-%typemap(in) SWIGTYPE *const& ($*ltype temp)
-{
-	if(SWIG_ConvertPtr(*$input, (void **) &temp, $*1_descriptor, 0) < 0) {
-            SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $*1_descriptor");
-	}
-	$1 = ($1_ltype)&temp;
-}
-
-%typemap(in) SWIGTYPE *DISOWN
-{
-  if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, SWIG_POINTER_DISOWN ) < 0) {
-    SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
-  }
-}
-
-%typemap(argout) SWIGTYPE *,
-                 SWIGTYPE [],
-                 SWIGTYPE&;
-
-%typemap(in) void *
-{
-	if(SWIG_ConvertPtr(*$input, (void **) &$1, 0, 0) < 0) {
-	  /* Allow NULL from php for void* */
-	  if ((*$input)->type==IS_NULL) $1=0;
-	  else
-            SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
-	}
-}
-
-/* Special case when void* is passed by reference so it can be made to point
-   to opaque api structs */
-%typemap(in) void ** ($*1_ltype ptr, int force),
-             void *& ($*1_ltype ptr, int force)
-{
-  /* If they pass NULL by reference, make it into a void*
-     This bit should go in arginit if arginit support init-ing scripting args */
-  if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0) {
-    /* So... we didn't get a ref or ptr, but we'll accept NULL by reference */
-    if (!((*$input)->type==IS_NULL && PZVAL_IS_REF(*$input))) {
-      /* wasn't a pre/ref/thing, OR anything like an int thing */
-      SWIG_PHP_Error(E_ERROR, "Type error in argument $arg of $symname.");
-    }
-  }
-  force=0;
-  if (arg1==NULL) {
-#ifdef __cplusplus
-    ptr=new $*1_ltype;
-#else
-    ptr=($*1_ltype) calloc(1,sizeof($*1_ltype));
-#endif
-    $1=&ptr;
-    /* have to passback arg$arg too */
-    force=1;
-  }
-}
-%typemap(argout) void **,
-                 void *&
-{
-  if (force$argnum) {
-    SWIG_SetPointerZval( *$input, (void*) ptr$argnum, $*1_descriptor, 1);
-  }
-}
-
-/* Typemap for output values */
-
-%typemap(out) int,
-              unsigned int,
-              short,
-              unsigned short,
-              long,
-              unsigned long,
-              signed char,
-              unsigned char,
-              bool,
-              size_t,
-              enum SWIGTYPE
-{
-	ZVAL_LONG(return_value,$1);
-}
-
-%typemap(out) long long
-%{
-  if ((long long)LONG_MIN <= $1 && $1 <= (long long)LONG_MAX) {
-    return_value->value.lval = (long)($1);
-    return_value->type = IS_LONG;
-  } else {
-    char temp[256];
-    sprintf(temp, "%lld", (long long)$1);
-    ZVAL_STRING(return_value, temp, 1);
-  }
-%}
-%typemap(out) unsigned long long
-%{
-  if ($1 <= (unsigned long long)LONG_MAX) {
-    return_value->value.lval = (long)($1);
-    return_value->type = IS_LONG;
-  } else {
-    char temp[256];
-    sprintf(temp, "%llu", (unsigned long long)$1);
-    ZVAL_STRING(return_value, temp, 1);
-  }
-%}
-
-%typemap(out) const int &,
-              const unsigned int &,
-              const short &,
-              const unsigned short &,
-              const long &,
-              const unsigned long &,
-              const signed char &,
-              const unsigned char &,
-              const bool &,
-              const size_t &,
-              const enum SWIGTYPE &
-{
-	ZVAL_LONG(return_value,*$1);
-}
-
-%typemap(out) const long long &
-%{
-  if ((long long)LONG_MIN <= *$1 && *$1 <= (long long)LONG_MAX) {
-    return_value->value.lval = (long)(*$1);
-    return_value->type = IS_LONG;
-  } else {
-    char temp[256];
-    sprintf(temp, "%lld", (long long)(*$1));
-    ZVAL_STRING(return_value, temp, 1);
-  }
-%}
-%typemap(out) const unsigned long long &
-%{
-  if (*$1 <= (unsigned long long)LONG_MAX) {
-    return_value->value.lval = (long)(*$1);
-    return_value->type = IS_LONG;
-  } else {
-    char temp[256];
-    sprintf(temp, "%llu", (unsigned long long)(*$1));
-    ZVAL_STRING(return_value, temp, 1);
-  }
-%}
-
-%typemap(directorin) int,
-              unsigned int,
-              short,
-              unsigned short,
-              long,
-              unsigned long,
-              signed char,
-              unsigned char,
-              size_t,
-              enum SWIGTYPE
-{
-  ZVAL_LONG($input,$1);
-}
-
-%typemap(directorin) char *, char []
-{
-    if(!$1) {
-      ZVAL_NULL($input);
-    } else {
-      ZVAL_STRING($input, (char *)$1, 1);
-    }
-}
-
-%typemap(out) bool
-{
-	ZVAL_BOOL(return_value,($1)?1:0);
-}
-
-%typemap(out) const bool &
-{
-	ZVAL_BOOL(return_value,(*$1)?1:0);
-}
-
-%typemap(directorin) bool
-{
-	ZVAL_BOOL($input,($1)?1:0);
-}
-
-%typemap(out) float,
-              double
-{
-	ZVAL_DOUBLE(return_value,$1);
-}
-
-%typemap(out) const float &,
-              const double &
-{
-	ZVAL_DOUBLE(return_value,*$1);
-}
-
-%typemap(directorin) float,
-                     double
-{
-	ZVAL_DOUBLE($input,$1);
-}
-
-%typemap(out) char
-{
-	ZVAL_STRINGL(return_value,&$1, 1, 1);
-}
-
-%typemap(out) const char &
-{
-	ZVAL_STRINGL(return_value,&*$1, 1, 1);
-}
-
-%typemap(out) char *,
-              char []
-{
-	if(!$1) {
-	  ZVAL_NULL(return_value);
-	} else {
-	  ZVAL_STRING(return_value, (char *)$1, 1);
-	}
-}
-
-%typemap(out) char *&
-{
-	if(!*$1) {
-	  ZVAL_NULL(return_value);
-	} else {
-	  ZVAL_STRING(return_value, (char *)*$1, 1);
-	}
-}
-
-%typemap(out) SWIGTYPE *,
-              SWIGTYPE [],
-              SWIGTYPE &
-%{
-  SWIG_SetPointerZval(return_value, (void *)$1, $1_descriptor, $owner);
-%}
-
-%typemap(out) SWIGTYPE *const&
-%{
-  SWIG_SetPointerZval(return_value, (void *)*$1, $*1_descriptor, $owner);
-%}
-
-%typemap(directorin) SWIGTYPE *,
-                     SWIGTYPE [],
-                     SWIGTYPE &
-%{
-  SWIG_SetPointerZval($input, (void *)&$1, $1_descriptor, ($owner)|2);
-%}
-
-%typemap(out, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
-{
-  void * p = emalloc(sizeof($1));
-  memcpy(p, &$1, sizeof($1));
-  zval * resource;
-  MAKE_STD_ZVAL(resource);
-  ZEND_REGISTER_RESOURCE(resource, p, swig_member_ptr);
-
-  SWIG_SetPointerZval(return_value, (void *)&$1, $1_descriptor, $owner);
-}
-
-%typemap(in, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
-{
-  void * p = (void*)zend_fetch_resource($input TSRMLS_CC, -1, SWIG_MEMBER_PTR, NULL, 1, swig_member_ptr);
-  memcpy(&$1, p, sizeof($1));
-}
-
-%typemap(out) SWIGTYPE *DYNAMIC,
-              SWIGTYPE &DYNAMIC
-{
-  swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor, (void **) &$1);
-  SWIG_SetPointerZval(return_value, (void *)$1, ty, $owner);
-}
-
-%typemap(out) SWIGTYPE
-#ifdef __cplusplus
-{
-  $&1_ltype resultobj = new $1_ltype((const $1_ltype &) $1);
-  SWIG_SetPointerZval(return_value, (void *)resultobj, $&1_descriptor, 1);
-}
-#else
-{
-  $&1_ltype resultobj = ($&1_ltype) emalloc(sizeof($1_type));
-  memcpy(resultobj, &$1, sizeof($1_type));
-  SWIG_SetPointerZval(return_value, (void *)resultobj, $&1_descriptor, 1);
-}
-#endif
-
-%typemap(directorin) SWIGTYPE
-{
-  SWIG_SetPointerZval($input, SWIG_as_voidptr(&$1), $&1_descriptor, 2);
-}
-
-%typemap(out) void "";
-
-%typemap(out) char [ANY]
-{
-  int len = 0;
-  while (len < $1_dim0 && $1[len]) ++len;
-  RETVAL_STRINGL($1, len, 1);
-}
-
-// This typecheck does hard checking for proper argument type.  If you want
-// an argument to be converted from a different PHP type, you must convert
-// it yourself before passing it (e.g. (string)4.7 or (int)"6").
-%define %php_typecheck(_type,_prec,is)
-%typemap(typecheck,precedence=_prec) _type, const _type &
- " $1 = (Z_TYPE_PP($input) == is); "
-%enddef
-
-%php_typecheck(int,SWIG_TYPECHECK_INTEGER,IS_LONG)
-%php_typecheck(unsigned int,SWIG_TYPECHECK_UINT32,IS_LONG)
-%php_typecheck(short,SWIG_TYPECHECK_INT16,IS_LONG)
-%php_typecheck(unsigned short,SWIG_TYPECHECK_UINT16,IS_LONG)
-%php_typecheck(long,SWIG_TYPECHECK_INT32,IS_LONG)
-%php_typecheck(unsigned long,SWIG_TYPECHECK_UINT32,IS_LONG)
-%php_typecheck(long long,SWIG_TYPECHECK_INT64,IS_LONG)
-%php_typecheck(unsigned long long,SWIG_TYPECHECK_UINT64,IS_LONG)
-%php_typecheck(signed char,SWIG_TYPECHECK_INT8,IS_LONG)
-%php_typecheck(unsigned char,SWIG_TYPECHECK_UINT8,IS_LONG)
-%php_typecheck(size_t,SWIG_TYPECHECK_SIZE,IS_LONG)
-%php_typecheck(enum SWIGTYPE,SWIG_TYPECHECK_INTEGER,IS_LONG)
-%php_typecheck(bool,SWIG_TYPECHECK_BOOL,IS_BOOL)
-%php_typecheck(float,SWIG_TYPECHECK_FLOAT,IS_DOUBLE)
-%php_typecheck(double,SWIG_TYPECHECK_DOUBLE,IS_DOUBLE)
-%php_typecheck(char,SWIG_TYPECHECK_CHAR,IS_STRING)
-
-%typemap(typecheck,precedence=SWIG_TYPECHECK_STRING) char *, char *&, char []
- " $1 = (Z_TYPE_PP($input) == IS_STRING); "
-
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE
-{
-  void *tmp;
-  _v = (SWIG_ConvertPtr(*$input, (void **)&tmp, $&1_descriptor, 0) >= 0);
-}
-
-%typecheck(SWIG_TYPECHECK_POINTER)
-             SWIGTYPE *,
-             SWIGTYPE [],
-             SWIGTYPE &,
-             SWIGTYPE *const&
-{
-  void *tmp;
-  _v = (SWIG_ConvertPtr(*$input, (void**)&tmp, $1_descriptor, 0) >= 0);
-}
-
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *const&
-{
-  void *tmp;
-  _v = (SWIG_ConvertPtr(*$input, (void**)&tmp, $*1_descriptor, 0) >= 0);
-}
-
-%typecheck(SWIG_TYPECHECK_VOIDPTR) void *
-{
-  void *tmp;
-  _v = (SWIG_ConvertPtr(*$input, (void**)&tmp, 0, 0) >= 0);
-}
-
-/* Exception handling */
-
-%typemap(throws) int,
-                 long,
-                 short,
-                 unsigned int,
-                 unsigned long,
-                 unsigned short {
-  zend_throw_exception(NULL, const_cast<char*>("C++ $1_type exception thrown"), $1 TSRMLS_CC);
-  return;
-}
-
-%typemap(throws) SWIGTYPE, SWIGTYPE &, SWIGTYPE *, SWIGTYPE [], SWIGTYPE [ANY] %{
-  (void)$1;
-  zend_throw_exception(NULL, const_cast<char*>("C++ $1_type exception thrown"), 0 TSRMLS_CC);
-  return;
-%}
-
-%typemap(throws) char * %{
-  zend_throw_exception(NULL, const_cast<char*>($1), 0 TSRMLS_CC);
-  return;
-%}
-
-/* Array reference typemaps */
-%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
-
-/* const pointers */
-%apply SWIGTYPE * { SWIGTYPE *const }
-
-
-/* php keywords */
-%include <phpkw.swg>
diff --git a/share/swig/2.0.11/php/phpinit.swg b/share/swig/2.0.11/php/phpinit.swg
deleted file mode 100644
index 6e5cc29..0000000
--- a/share/swig/2.0.11/php/phpinit.swg
+++ /dev/null
@@ -1,25 +0,0 @@
-
-/* ------------------------------------------------------------
- * The start of the PHP initialization function 
- * ------------------------------------------------------------ */
-
-%insert(init) "swiginit.swg"
-
-%init %{
-  SWIG_php_minit {
-    SWIG_InitializeModule(0);
-%}
-
-%fragment("swig_php_init_member_ptr2", "header") {
-#define SWIG_MEMBER_PTR ((char*)"CLASS::*")
-
-static void swig_member_ptr_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) {
-  efree(rsrc->ptr);
-}
-
-static int swig_member_ptr = 0;
-}
-
-%fragment("swig_php_init_member_ptr", "init", fragment="swig_php_init_member_ptr2") {
-    swig_member_ptr = zend_register_list_destructors_ex(swig_member_ptr_dtor, NULL, SWIG_MEMBER_PTR, module_number);
-}
diff --git a/share/swig/2.0.11/php/phpkw.swg b/share/swig/2.0.11/php/phpkw.swg
deleted file mode 100644
index c557669..0000000
--- a/share/swig/2.0.11/php/phpkw.swg
+++ /dev/null
@@ -1,616 +0,0 @@
-/* -----------------------------------------------------------------------------
- * phpkw.swg
- * ----------------------------------------------------------------------------- */
-
-#define PHPKW(x) %keywordwarn("'" `x` "' is a PHP keyword, renamed as 'c_" `x` "'",sourcefmt="%(lower)s",rename="c_%s") `x`
-
-#define PHPCN(x) %keywordwarn("'" `x` "' is a PHP reserved class name, class renamed as 'c_" `x` "'",%$isclass,sourcefmt="%(lower)s",rename="c_%s") `x`
-
-#define PHPBN1(x) %builtinwarn("'" `x` "' conflicts with a built-in name in PHP",sourcefmt="%(lower)s") `x`
-#define PHPBN2(x) %builtinwarn("'" `x` "' conflicts with a built-in name in PHP") "::" `x`
-#define PHPFN(x) %keywordwarn("'" `x` "' is a PHP built-in function, renamed as 'c_" `x` "'",sourcefmt="%(lower)s",%$isfunction,%$not %$ismember,rename="c_%s") `x`
-
-/*
-   From
-
-     http://aspn.activestate.com/ASPN/docs/PHP/reserved.html
-     http://php.net/manual/en/reserved.keywords.php
-
-   and reviewed by Olly Betts.
-
-   Further updates from the PHP manual on php.net.
-*/
-
-/* We classify these as kw since PHP will not run if used globally. */
-/* "You cannot use any of the following words as constants, class names,
- * function or method names. Using them as variable names is generally OK, but
- * could lead to confusion."
- */
-/* case insensitive */
-PHPKW(__halt_compiler);
-PHPKW(abstract);
-PHPKW(and);
-PHPKW(array);
-PHPKW(as);
-PHPKW(break);
-PHPKW(case);
-PHPKW(catch);
-PHPKW(class);
-PHPKW(clone);
-PHPKW(const);
-PHPKW(continue);
-PHPKW(declare);
-PHPKW(default);
-PHPKW(die); // "Language construct"
-PHPKW(do);
-PHPKW(echo); // "Language construct"
-PHPKW(else);
-PHPKW(elseif);
-PHPKW(empty); // "Language construct"
-PHPKW(enddeclare);
-PHPKW(endfor);
-PHPKW(endforeach);
-PHPKW(endif);
-PHPKW(endswitch);
-PHPKW(endwhile);
-PHPKW(eval); // "Language construct"
-PHPKW(exit); // "Language construct"
-PHPKW(extends);
-PHPKW(final);
-PHPKW(for);
-PHPKW(foreach);
-PHPKW(function);
-PHPKW(global);
-PHPKW(goto); // As of PHP5.3
-PHPKW(if);
-PHPKW(implements);
-PHPKW(include); // "Language construct"
-PHPKW(include_once); // "Language construct"
-PHPKW(instanceof);
-PHPKW(interface);
-PHPKW(isset); // "Language construct"
-PHPKW(list); // "Language construct"
-PHPKW(namespace); // As of PHP5.3
-PHPKW(new);
-PHPKW(or);
-PHPKW(print); // "Language construct"
-PHPKW(private);
-PHPKW(protected);
-PHPKW(public);
-PHPKW(require); // "Language construct"
-PHPKW(require_once); // "Language construct"
-PHPKW(return); // "Language construct"
-PHPKW(static);
-PHPKW(switch);
-PHPKW(throw);
-PHPKW(try);
-PHPKW(unset); // "Language construct"
-PHPKW(use);
-PHPKW(var);
-PHPKW(while);
-PHPKW(xor);
-// Compile-time constants
-PHPKW(__CLASS__);
-PHPKW(__DIR__); // As of PHP5.3
-PHPKW(__FILE__);
-PHPKW(__FUNCTION__);
-PHPKW(__METHOD__);
-PHPKW(__NAMESPACE__); // As of PHP5.3
-PHPKW(__LINE__);
-
-/* We classify these as built-in names since they conflict, but PHP still runs */
-
-/* Type 1: case insensitive */
-PHPBN1(__sleep);
-PHPBN1(__wakeup);
-PHPBN1(not);
-PHPBN1(parent);
-PHPBN1(virtual);
-PHPBN1(NULL);
-PHPBN1(TRUE);
-PHPBN1(FALSE);
-
-/* Type 2: case sensitive */
-/* "Core Predefined Constants" from http://uk2.php.net/manual/en/reserved.constants.php */
-PHPBN2(E_ALL);
-PHPBN2(E_ERROR);
-PHPBN2(E_PARSE);
-PHPBN2(E_WARNING);
-PHPBN2(E_NOTICE);
-PHPBN2(E_CORE_ERROR);
-PHPBN2(E_CORE_WARNING);
-PHPBN2(E_COMPILE_ERROR);
-PHPBN2(E_COMPILE_WARNING);
-PHPBN2(E_USER_ERROR);
-PHPBN2(E_USER_WARNING);
-PHPBN2(E_USER_NOTICE);
-PHPBN2(E_DEPRECATED); // As of PHP 5.3
-PHPBN2(E_USER_DEPRECATED); // As of PHP 5.3
-PHPBN2(PHP_OS);
-PHPBN2(PHP_VERSION);
-PHPBN2(PHP_SAPI);
-PHPBN2(PHP_EOL);
-PHPBN2(PHP_INT_MAX);
-PHPBN2(PHP_INT_SIZE);
-PHPBN2(DEFAULT_INCLUDE_PATH);
-PHPBN2(PEAR_INSTALL_DIR);
-PHPBN2(PEAR_EXTENSION_DIR);
-PHPBN2(PHP_EXTENSION_DIR);
-PHPBN2(PHP_PREFIX);
-PHPBN2(PHP_BINDIR);
-PHPBN2(PHP_LIBDIR);
-PHPBN2(PHP_DATADIR);
-PHPBN2(PHP_SYSCONFDIR);
-PHPBN2(PHP_LOCALSTATEDIR);
-PHPBN2(PHP_CONFIG_FILE_PATH);
-PHPBN2(PHP_CONFIG_FILE_SCAN_DIR);
-PHPBN2(PHP_SHLIB_SUFFIX);
-PHPBN2(PHP_OUTPUT_HANDLER_START);
-PHPBN2(PHP_OUTPUT_HANDLER_CONT);
-PHPBN2(PHP_OUTPUT_HANDLER_END);
-PHPBN2(PHP_MAXPATHLEN); // As of PHP 5.3
-/* These don't actually seem to be set (tested on Linux, I guess they're
- * Windows only?) */
-PHPBN2(PHP_WINDOWS_NT_DOMAIN_CONTROLLER); // As of PHP 5.3
-PHPBN2(PHP_WINDOWS_NT_SERVER); // As of PHP 5.3
-PHPBN2(PHP_WINDOWS_NT_WORKSTATION); // As of PHP 5.3
-PHPBN2(PHP_WINDOWS_VERSION_BUILD); // As of PHP 5.3
-PHPBN2(PHP_WINDOWS_VERSION_MAJOR); // As of PHP 5.3
-PHPBN2(PHP_WINDOWS_VERSION_MINOR); // As of PHP 5.3
-PHPBN2(PHP_WINDOWS_VERSION_PLATFORM); // As of PHP 5.3
-PHPBN2(PHP_WINDOWS_VERSION_PRODUCTTYPE); // As of PHP 5.3
-PHPBN2(PHP_WINDOWS_VERSION_SP_MAJOR); // As of PHP 5.3
-PHPBN2(PHP_WINDOWS_VERSION_SP_MINOR); // As of PHP 5.3
-PHPBN2(PHP_WINDOWS_VERSION_SUITEMASK); // As of PHP 5.3
-/* "Standard Predefined Constants" from http://uk2.php.net/manual/en/reserved.constants.php */
-PHPBN2(EXTR_OVERWRITE);
-PHPBN2(EXTR_SKIP);
-PHPBN2(EXTR_PREFIX_SAME);
-PHPBN2(EXTR_PREFIX_ALL);
-PHPBN2(EXTR_PREFIX_INVALID);
-PHPBN2(EXTR_PREFIX_IF_EXISTS);
-PHPBN2(EXTR_IF_EXISTS);
-PHPBN2(SORT_ASC);
-PHPBN2(SORT_DESC);
-PHPBN2(SORT_REGULAR);
-PHPBN2(SORT_NUMERIC);
-PHPBN2(SORT_STRING);
-PHPBN2(CASE_LOWER);
-PHPBN2(CASE_UPPER);
-PHPBN2(COUNT_NORMAL);
-PHPBN2(COUNT_RECURSIVE);
-PHPBN2(ASSERT_ACTIVE);
-PHPBN2(ASSERT_CALLBACK);
-PHPBN2(ASSERT_BAIL);
-PHPBN2(ASSERT_WARNING);
-PHPBN2(ASSERT_QUIET_EVAL);
-PHPBN2(CONNECTION_ABORTED);
-PHPBN2(CONNECTION_NORMAL);
-PHPBN2(CONNECTION_TIMEOUT);
-PHPBN2(INI_USER);
-PHPBN2(INI_PERDIR);
-PHPBN2(INI_SYSTEM);
-PHPBN2(INI_ALL);
-PHPBN2(INI_SCANNER_NORMAL); // As of PHP 5.3
-PHPBN2(INI_SCANNER_RAW); // As of PHP 5.3
-PHPBN2(M_E);
-PHPBN2(M_LOG2E);
-PHPBN2(M_LOG10E);
-PHPBN2(M_LN2);
-PHPBN2(M_LN10);
-PHPBN2(M_PI);
-PHPBN2(M_PI_2);
-PHPBN2(M_PI_4);
-PHPBN2(M_1_PI);
-PHPBN2(M_2_PI);
-PHPBN2(M_2_SQRTPI);
-PHPBN2(M_SQRT2);
-PHPBN2(M_SQRT1_2);
-PHPBN2(M_EULER); // As of PHP 5.2
-PHPBN2(M_LNPI); // As of PHP 5.2
-PHPBN2(M_SQRT3); // As of PHP 5.2
-PHPBN2(M_SQRTPI); // As of PHP 5.2
-PHPBN2(CRYPT_SALT_LENGTH);
-PHPBN2(CRYPT_STD_DES);
-PHPBN2(CRYPT_EXT_DES);
-PHPBN2(CRYPT_MD5);
-PHPBN2(CRYPT_BLOWFISH);
-PHPBN2(DIRECTORY_SEPARATOR);
-PHPBN2(SEEK_SET);
-PHPBN2(SEEK_CUR);
-PHPBN2(SEEK_END);
-PHPBN2(LOCK_SH);
-PHPBN2(LOCK_EX);
-PHPBN2(LOCK_UN);
-PHPBN2(LOCK_NB);
-PHPBN2(HTML_SPECIALCHARS);
-PHPBN2(HTML_ENTITIES);
-PHPBN2(ENT_COMPAT);
-PHPBN2(ENT_QUOTES);
-PHPBN2(ENT_NOQUOTES);
-PHPBN2(INFO_GENERAL);
-PHPBN2(INFO_CREDITS);
-PHPBN2(INFO_CONFIGURATION);
-PHPBN2(INFO_MODULES);
-PHPBN2(INFO_ENVIRONMENT);
-PHPBN2(INFO_VARIABLES);
-PHPBN2(INFO_LICENSE);
-PHPBN2(INFO_ALL);
-PHPBN2(CREDITS_GROUP);
-PHPBN2(CREDITS_GENERAL);
-PHPBN2(CREDITS_SAPI);
-PHPBN2(CREDITS_MODULES);
-PHPBN2(CREDITS_DOCS);
-PHPBN2(CREDITS_FULLPAGE);
-PHPBN2(CREDITS_QA);
-PHPBN2(CREDITS_ALL);
-PHPBN2(STR_PAD_LEFT);
-PHPBN2(STR_PAD_RIGHT);
-PHPBN2(STR_PAD_BOTH);
-PHPBN2(PATHINFO_DIRNAME);
-PHPBN2(PATHINFO_BASENAME);
-PHPBN2(PATHINFO_EXTENSION);
-PHPBN2(PATHINFO_FILENAME); // As of PHP 5.2
-PHPBN2(PATH_SEPARATOR);
-PHPBN2(CHAR_MAX);
-PHPBN2(LC_CTYPE);
-PHPBN2(LC_NUMERIC);
-PHPBN2(LC_TIME);
-PHPBN2(LC_COLLATE);
-PHPBN2(LC_MONETARY);
-PHPBN2(LC_ALL);
-PHPBN2(LC_MESSAGES);
-PHPBN2(ABDAY_1);
-PHPBN2(ABDAY_2);
-PHPBN2(ABDAY_3);
-PHPBN2(ABDAY_4);
-PHPBN2(ABDAY_5);
-PHPBN2(ABDAY_6);
-PHPBN2(ABDAY_7);
-PHPBN2(DAY_1);
-PHPBN2(DAY_2);
-PHPBN2(DAY_3);
-PHPBN2(DAY_4);
-PHPBN2(DAY_5);
-PHPBN2(DAY_6);
-PHPBN2(DAY_7);
-PHPBN2(ABMON_1);
-PHPBN2(ABMON_2);
-PHPBN2(ABMON_3);
-PHPBN2(ABMON_4);
-PHPBN2(ABMON_5);
-PHPBN2(ABMON_6);
-PHPBN2(ABMON_7);
-PHPBN2(ABMON_8);
-PHPBN2(ABMON_9);
-PHPBN2(ABMON_10);
-PHPBN2(ABMON_11);
-PHPBN2(ABMON_12);
-PHPBN2(MON_1);
-PHPBN2(MON_2);
-PHPBN2(MON_3);
-PHPBN2(MON_4);
-PHPBN2(MON_5);
-PHPBN2(MON_6);
-PHPBN2(MON_7);
-PHPBN2(MON_8);
-PHPBN2(MON_9);
-PHPBN2(MON_10);
-PHPBN2(MON_11);
-PHPBN2(MON_12);
-PHPBN2(AM_STR);
-PHPBN2(PM_STR);
-PHPBN2(D_T_FMT);
-PHPBN2(D_FMT);
-PHPBN2(T_FMT);
-PHPBN2(T_FMT_AMPM);
-PHPBN2(ERA);
-PHPBN2(ERA_YEAR);
-PHPBN2(ERA_D_T_FMT);
-PHPBN2(ERA_D_FMT);
-PHPBN2(ERA_T_FMT);
-PHPBN2(ALT_DIGITS);
-PHPBN2(INT_CURR_SYMBOL);
-PHPBN2(CURRENCY_SYMBOL);
-PHPBN2(CRNCYSTR);
-PHPBN2(MON_DECIMAL_POINT);
-PHPBN2(MON_THOUSANDS_SEP);
-PHPBN2(MON_GROUPING);
-PHPBN2(POSITIVE_SIGN);
-PHPBN2(NEGATIVE_SIGN);
-PHPBN2(INT_FRAC_DIGITS);
-PHPBN2(FRAC_DIGITS);
-PHPBN2(P_CS_PRECEDES);
-PHPBN2(P_SEP_BY_SPACE);
-PHPBN2(N_CS_PRECEDES);
-PHPBN2(N_SEP_BY_SPACE);
-PHPBN2(P_SIGN_POSN);
-PHPBN2(N_SIGN_POSN);
-PHPBN2(DECIMAL_POINT);
-PHPBN2(RADIXCHAR);
-PHPBN2(THOUSANDS_SEP);
-PHPBN2(THOUSEP);
-PHPBN2(GROUPING);
-PHPBN2(YESEXPR);
-PHPBN2(NOEXPR);
-PHPBN2(YESSTR);
-PHPBN2(NOSTR);
-PHPBN2(CODESET);
-PHPBN2(LOG_EMERG);
-PHPBN2(LOG_ALERT);
-PHPBN2(LOG_CRIT);
-PHPBN2(LOG_ERR);
-PHPBN2(LOG_WARNING);
-PHPBN2(LOG_NOTICE);
-PHPBN2(LOG_INFO);
-PHPBN2(LOG_DEBUG);
-PHPBN2(LOG_KERN);
-PHPBN2(LOG_USER);
-PHPBN2(LOG_MAIL);
-PHPBN2(LOG_DAEMON);
-PHPBN2(LOG_AUTH);
-PHPBN2(LOG_SYSLOG);
-PHPBN2(LOG_LPR);
-PHPBN2(LOG_NEWS);
-PHPBN2(LOG_UUCP);
-PHPBN2(LOG_CRON);
-PHPBN2(LOG_AUTHPRIV);
-PHPBN2(LOG_LOCAL0);
-PHPBN2(LOG_LOCAL1);
-PHPBN2(LOG_LOCAL2);
-PHPBN2(LOG_LOCAL3);
-PHPBN2(LOG_LOCAL4);
-PHPBN2(LOG_LOCAL5);
-PHPBN2(LOG_LOCAL6);
-PHPBN2(LOG_LOCAL7);
-PHPBN2(LOG_PID);
-PHPBN2(LOG_CONS);
-PHPBN2(LOG_ODELAY);
-PHPBN2(LOG_NDELAY);
-PHPBN2(LOG_NOWAIT);
-PHPBN2(LOG_PERROR);
-
-/* Added in PHP5 */
-PHPBN2(E_STRICT);
-PHPBN2(__COMPILER_HALT_OFFSET__);
-
-/* Added in PHP 5.2 */
-PHPBN2(PREG_BACKTRACK_LIMIT_ERROR);
-PHPBN2(PREG_BAD_UTF8_ERROR);
-PHPBN2(PREG_INTERNAL_ERROR);
-PHPBN2(PREG_NO_ERROR);
-PHPBN2(PREG_RECURSION_LIMIT_ERROR);
-PHPBN2(UPLOAD_ERR_EXTENSION);
-PHPBN2(STREAM_SHUT_RD);
-PHPBN2(STREAM_SHUT_WR);
-PHPBN2(STREAM_SHUT_RDWR);
-PHPBN2(CURLE_FILESIZE_EXCEEDED);
-PHPBN2(CURLE_FTP_SSL_FAILED);
-PHPBN2(CURLE_LDAP_INVALID_URL);
-PHPBN2(CURLFTPAUTH_DEFAULT);
-PHPBN2(CURLFTPAUTH_SSL);
-PHPBN2(CURLFTPAUTH_TLS);
-PHPBN2(CURLFTPSSL_ALL);
-PHPBN2(CURLFTPSSL_CONTROL);
-PHPBN2(CURLFTPSSL_NONE);
-PHPBN2(CURLFTPSSL_TRY);
-PHPBN2(CURLOPT_FTP_SSL);
-PHPBN2(CURLOPT_FTPSSLAUTH);
-PHPBN2(CURLOPT_TCP_NODELAY); // Added in PHP 5.2.1
-PHPBN2(CURLOPT_TIMEOUT_MS); // Added in PHP 5.2.3
-PHPBN2(CURLOPT_CONNECTTIMEOUT_MS); // Added in PHP 5.2.3
-PHPBN2(GMP_VERSION); // Added in PHP 5.2.2
-PHPBN2(SWFTEXTFIELD_USEFONT);
-PHPBN2(SWFTEXTFIELD_AUTOSIZE);
-PHPBN2(SWF_SOUND_NOT_COMPRESSED);
-PHPBN2(SWF_SOUND_ADPCM_COMPRESSED);
-PHPBN2(SWF_SOUND_MP3_COMPRESSED);
-PHPBN2(SWF_SOUND_NOT_COMPRESSED_LE);
-PHPBN2(SWF_SOUND_NELLY_COMPRESSED);
-PHPBN2(SWF_SOUND_5KHZ);
-PHPBN2(SWF_SOUND_11KHZ);
-PHPBN2(SWF_SOUND_22KHZ);
-PHPBN2(SWF_SOUND_44KHZ);
-PHPBN2(SWF_SOUND_8BITS);
-PHPBN2(SWF_SOUND_16BITS);
-PHPBN2(SWF_SOUND_MONO);
-PHPBN2(SWF_SOUND_STEREO);
-PHPBN2(OPENSSL_VERSION_NUMBER);
-PHPBN2(SNMP_OID_OUTPUT_FULL);
-PHPBN2(SNMP_OID_OUTPUT_NUMERIC);
-PHPBN2(MSG_EAGAIN);
-PHPBN2(MSG_ENOMSG);
-
-/* Added in PHP 5.3 */
-PHPBN2(CURLOPT_PROGRESSFUNCTION);
-PHPBN2(IMG_FILTER_PIXELATE);
-PHPBN2(JSON_ERROR_CTRL_CHAR);
-PHPBN2(JSON_ERROR_DEPTH);
-PHPBN2(JSON_ERROR_NONE);
-PHPBN2(JSON_ERROR_STATE_MISMATCH);
-PHPBN2(JSON_ERROR_SYNTAX);
-PHPBN2(JSON_FORCE_OBJECT);
-PHPBN2(JSON_HEX_TAG);
-PHPBN2(JSON_HEX_AMP);
-PHPBN2(JSON_HEX_APOS);
-PHPBN2(JSON_HEX_QUOT);
-PHPBN2(LDAP_OPT_NETWORK_TIMEOUT);
-PHPBN2(LIBXML_LOADED_VERSION);
-PHPBN2(PREG_BAD_UTF8_OFFSET_ERROR);
-PHPBN2(BUS_ADRALN);
-PHPBN2(BUS_ADRERR);
-PHPBN2(BUS_OBJERR);
-PHPBN2(CLD_CONTIUNED);
-PHPBN2(CLD_DUMPED);
-PHPBN2(CLD_EXITED);
-PHPBN2(CLD_KILLED);
-PHPBN2(CLD_STOPPED);
-PHPBN2(CLD_TRAPPED);
-PHPBN2(FPE_FLTDIV);
-PHPBN2(FPE_FLTINV);
-PHPBN2(FPE_FLTOVF);
-PHPBN2(FPE_FLTRES);
-PHPBN2(FPE_FLTSUB);
-PHPBN2(FPE_FLTUND);
-PHPBN2(FPE_INTDIV);
-PHPBN2(FPE_INTOVF);
-PHPBN2(ILL_BADSTK);
-PHPBN2(ILL_COPROC);
-PHPBN2(ILL_ILLADR);
-PHPBN2(ILL_ILLOPC);
-PHPBN2(ILL_ILLOPN);
-PHPBN2(ILL_ILLTRP);
-PHPBN2(ILL_PRVOPC);
-PHPBN2(ILL_PRVREG);
-PHPBN2(POLL_ERR);
-PHPBN2(POLL_HUP);
-PHPBN2(POLL_IN);
-PHPBN2(POLL_MSG);
-PHPBN2(POLL_OUT);
-PHPBN2(POLL_PRI);
-PHPBN2(SEGV_ACCERR);
-PHPBN2(SEGV_MAPERR);
-PHPBN2(SI_ASYNCIO);
-PHPBN2(SI_KERNEL);
-PHPBN2(SI_MESGQ);
-PHPBN2(SI_NOINFO);
-PHPBN2(SI_QUEUE);
-PHPBN2(SI_SIGIO);
-PHPBN2(SI_TIMER);
-PHPBN2(SI_TKILL);
-PHPBN2(SI_USER);
-PHPBN2(SIG_BLOCK);
-PHPBN2(SIG_SETMASK);
-PHPBN2(SIG_UNBLOCK);
-PHPBN2(TRAP_BRKPT);
-PHPBN2(TRAP_TRACE);
-
-/* Class names reserved by PHP */
-/* case insensitive */
-PHPCN(stdclass);
-PHPCN(__php_incomplete_class);
-PHPCN(directory);
-/* Added in PHP5 (this list apparently depends which extensions you load by default). */
-PHPCN(parent);
-PHPCN(self);
-PHPCN(exception);
-PHPCN(php_user_filter);
-PHPCN(errorexception);
-PHPCN(xmlwriter);
-PHPCN(libxmlerror);
-PHPCN(simplexmlelement);
-PHPCN(soapclient);
-PHPCN(soapvar);
-PHPCN(soapserver);
-PHPCN(soapfault);
-PHPCN(soapparam);
-PHPCN(soapheader);
-PHPCN(recursiveiteratoriterator);
-PHPCN(filteriterator);
-PHPCN(recursivefilteriterator);
-PHPCN(parentiterator);
-PHPCN(limititerator);
-PHPCN(cachingiterator);
-PHPCN(recursivecachingiterator);
-PHPCN(iteratoriterator);
-PHPCN(norewinditerator);
-PHPCN(appenditerator);
-PHPCN(infiniteiterator);
-PHPCN(emptyiterator);
-PHPCN(arrayobject);
-PHPCN(arrayiterator);
-PHPCN(recursivearrayiterator);
-PHPCN(splfileinfo);
-PHPCN(directoryiterator);
-PHPCN(recursivedirectoryiterator);
-PHPCN(splfileobject);
-PHPCN(spltempfileobject);
-PHPCN(simplexmliterator);
-PHPCN(logicexception);
-PHPCN(badfunctioncallexception);
-PHPCN(badmethodcallexception);
-PHPCN(domainexception);
-PHPCN(invalidargumentexception);
-PHPCN(lengthexception);
-PHPCN(outofrangeexception);
-PHPCN(runtimeexception);
-PHPCN(outofboundsexception);
-PHPCN(overflowexception);
-PHPCN(rangeexception);
-PHPCN(underflowexception);
-PHPCN(unexpectedvalueexception);
-PHPCN(splobjectstorage);
-PHPCN(reflectionexception);
-PHPCN(reflection);
-PHPCN(reflectionfunction);
-PHPCN(reflectionparameter);
-PHPCN(reflectionmethod);
-PHPCN(reflectionclass);
-PHPCN(reflectionobject);
-PHPCN(reflectionproperty);
-PHPCN(reflectionextension);
-PHPCN(domexception);
-PHPCN(domstringlist);
-PHPCN(domnamelist);
-PHPCN(domimplementationlist);
-PHPCN(domimplementationsource);
-PHPCN(domimplementation);
-PHPCN(domnode);
-PHPCN(domnamespacenode);
-PHPCN(domdocumentfragment);
-PHPCN(domdocument);
-PHPCN(domnodelist);
-PHPCN(domnamednodemap);
-PHPCN(domcharacterdata);
-PHPCN(domattr);
-PHPCN(domelement);
-PHPCN(domtext);
-PHPCN(domcomment);
-PHPCN(domtypeinfo);
-PHPCN(domuserdatahandler);
-PHPCN(domdomerror);
-PHPCN(domerrorhandler);
-PHPCN(domlocator);
-PHPCN(domconfiguration);
-PHPCN(domcdatasection);
-PHPCN(domdocumenttype);
-PHPCN(domnotation);
-PHPCN(domentity);
-PHPCN(domentityreference);
-PHPCN(domprocessinginstruction);
-PHPCN(domstringextend);
-PHPCN(domxpath);
-PHPCN(xmlreader);
-PHPCN(sqlitedatabase);
-PHPCN(sqliteresult);
-PHPCN(sqliteunbuffered);
-PHPCN(sqliteexception);
-PHPCN(datetime);
-
-/* Built-in PHP functions (incomplete). */
-PHPFN(cos);
-PHPFN(sin);
-PHPFN(tan);
-PHPFN(acos);
-PHPFN(asin);
-PHPFN(atan);
-PHPFN(atan2);
-PHPFN(cosh);
-PHPFN(sinh);
-PHPFN(tanh);
-PHPFN(exp);
-PHPFN(log);
-PHPFN(log10);
-PHPFN(pow);
-PHPFN(sqrt);
-PHPFN(ceil);
-PHPFN(floor);
-PHPFN(fmod);
-PHPFN(min);
-PHPFN(max);
-
-#undef PHPKW
-#undef PHPBN1
-#undef PHPBN2
-#undef PHPCN
-#undef PHPFN
diff --git a/share/swig/2.0.11/php/phppointers.i b/share/swig/2.0.11/php/phppointers.i
deleted file mode 100644
index 91b2c6d..0000000
--- a/share/swig/2.0.11/php/phppointers.i
+++ /dev/null
@@ -1,42 +0,0 @@
-%define %pass_by_ref( TYPE, CONVERT_IN, CONVERT_OUT )
-%typemap(in) TYPE *REF ($*1_ltype tmp),
-             TYPE &REF ($*1_ltype tmp)
-%{
-  /* First Check for SWIG wrapped type */
-  if ( ZVAL_IS_NULL( *$input ) ) {
-      $1 = 0;
-  } else if ( PZVAL_IS_REF( *$input ) ) {
-      /* Not swig wrapped type, so we check if it's a PHP reference type */
-      CONVERT_IN( tmp, $*1_ltype, $input );
-      $1 = &tmp;
-  } else {
-      SWIG_PHP_Error( E_ERROR, SWIG_PHP_Arg_Error_Msg($argnum, Expected a reference) );
-  }
-%}
-%typemap(argout) TYPE *REF,
-                 TYPE &REF
-  "CONVERT_OUT(*$input, tmp$argnum );";
-%enddef
-
-%pass_by_ref( size_t, CONVERT_INT_IN, ZVAL_LONG );
-
-%pass_by_ref( signed int, CONVERT_INT_IN, ZVAL_LONG );
-%pass_by_ref( int, CONVERT_INT_IN, ZVAL_LONG );
-%pass_by_ref( unsigned int, CONVERT_INT_IN, ZVAL_LONG );
-
-%pass_by_ref( signed short, CONVERT_INT_IN, ZVAL_LONG );
-%pass_by_ref( short, CONVERT_INT_IN, ZVAL_LONG );
-%pass_by_ref( unsigned short, CONVERT_INT_IN, ZVAL_LONG );
-
-%pass_by_ref( signed long, CONVERT_INT_IN, ZVAL_LONG );
-%pass_by_ref( long, CONVERT_INT_IN, ZVAL_LONG );
-%pass_by_ref( unsigned long, CONVERT_INT_IN, ZVAL_LONG );
-
-%pass_by_ref( signed char, CONVERT_INT_IN, ZVAL_LONG );
-%pass_by_ref( char, CONVERT_CHAR_IN, ZVAL_STRING );
-%pass_by_ref( unsigned char, CONVERT_INT_IN, ZVAL_LONG );
-
-%pass_by_ref( float, CONVERT_FLOAT_IN, ZVAL_DOUBLE );
-%pass_by_ref( double, CONVERT_FLOAT_IN, ZVAL_DOUBLE );
-
-%pass_by_ref( char *, CONVERT_CHAR_IN, ZVAL_STRING );
diff --git a/share/swig/2.0.11/php/phprun.swg b/share/swig/2.0.11/php/phprun.swg
deleted file mode 100644
index a4188cc..0000000
--- a/share/swig/2.0.11/php/phprun.swg
+++ /dev/null
@@ -1,275 +0,0 @@
-/* -----------------------------------------------------------------------------
- * phprun.swg
- *
- * PHP runtime library
- * ----------------------------------------------------------------------------- */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include "zend.h"
-#include "zend_API.h"
-#include "zend_exceptions.h"
-#include "php.h"
-#include "ext/standard/php_string.h"
-#include <stdlib.h> /* for abort(), used in generated code. */
-
-#ifdef ZEND_RAW_FENTRY
-/* ZEND_RAW_FENTRY was added somewhere between 5.2.0 and 5.2.3 */
-# define SWIG_ZEND_NAMED_FE(ZN, N, A) ZEND_RAW_FENTRY((char*)#ZN, N, A, 0)
-#else
-/* This causes warnings from GCC >= 4.2 (assigning a string literal to char*).
- * But this seems to be unavoidable without directly assuming knowledge of
- * the structure, which changed between PHP4 and PHP5. */
-# define SWIG_ZEND_NAMED_FE(ZN, N, A) ZEND_NAMED_FE(ZN, N, A)
-#endif
-
-#ifndef Z_SET_ISREF_P
-/* For PHP < 5.3 */
-# define Z_SET_ISREF_P(z) (z)->is_ref = 1
-#endif
-#ifndef Z_SET_REFCOUNT_P
-/* For PHP < 5.3 */
-# define Z_SET_REFCOUNT_P(z, rc) (z)->refcount = (rc)
-#endif
-
-#define SWIG_LONG_CONSTANT(N, V) zend_register_long_constant((char*)#N, sizeof(#N), V, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC)
-#define SWIG_DOUBLE_CONSTANT(N, V) zend_register_double_constant((char*)#N, sizeof(#N), V, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC)
-#define SWIG_STRING_CONSTANT(N, V) zend_register_stringl_constant((char*)#N, sizeof(#N), (char*)(V), strlen(V), CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC)
-#define SWIG_CHAR_CONSTANT(N, V) do {\
-    static char swig_char = (V);\
-    zend_register_stringl_constant((char*)#N, sizeof(#N), &swig_char, 1, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC);\
-} while (0)
-
-/* These TSRMLS_ stuff should already be defined now, but with older php under
-   redhat are not... */
-#ifndef TSRMLS_D
-#define TSRMLS_D
-#endif
-#ifndef TSRMLS_DC
-#define TSRMLS_DC
-#endif
-#ifndef TSRMLS_C
-#define TSRMLS_C
-#endif
-#ifndef TSRMLS_CC
-#define TSRMLS_CC
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-/* But in fact SWIG_ConvertPtr is the native interface for getting typed
-   pointer values out of zvals.  We need the TSRMLS_ macros for when we
-   make PHP type calls later as we handle php resources */
-#define SWIG_ConvertPtr(obj,pp,type,flags) SWIG_ZTS_ConvertPtr(obj,pp,type,flags TSRMLS_CC)
-
-
-#define SWIG_fail goto fail
-
-static const char *default_error_msg = "Unknown error occurred";
-static int default_error_code = E_ERROR;
-
-#define SWIG_PHP_Arg_Error_Msg(argnum,extramsg) "Error in argument " #argnum " "#extramsg
-
-#define SWIG_PHP_Error(code,msg) do { SWIG_ErrorCode() = code; SWIG_ErrorMsg() = msg; SWIG_fail; } while (0)
-
-#define SWIG_contract_assert(expr,msg) \
-  if (!(expr) ) { zend_printf("Contract Assert Failed %s\n",msg ); } else
-
-/* Standard SWIG API */
-#define SWIG_GetModule(clientdata) SWIG_Php_GetModule(clientdata)
-#define SWIG_SetModule(clientdata, pointer) SWIG_Php_SetModule(pointer)
-
-/* used to wrap returned objects in so we know whether they are newobject
-   and need freeing, or not */
-typedef struct {
-  void * ptr;
-  int newobject;
-} swig_object_wrapper;
-
-/* empty zend destructor for types without one */
-static ZEND_RSRC_DTOR_FUNC(SWIG_landfill) { (void)rsrc; }
-
-#define SWIG_SetPointerZval(a,b,c,d) SWIG_ZTS_SetPointerZval(a,b,c,d TSRMLS_CC)
-#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
-
-static void
-SWIG_ZTS_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject TSRMLS_DC) {
-  /*
-   * First test for Null pointers.  Return those as PHP native NULL
-   */
-  if (!ptr ) {
-    ZVAL_NULL(z);
-    return;
-  }
-  if (type->clientdata) {
-    swig_object_wrapper *value;
-    if (! (*(int *)(type->clientdata)))
-      zend_error(E_ERROR, "Type: %s failed to register with zend",type->name);
-    value=(swig_object_wrapper *)emalloc(sizeof(swig_object_wrapper));
-    value->ptr=ptr;
-    value->newobject=(newobject & 1);
-    if ((newobject & 2) == 0) {
-      /* Just register the pointer as a resource. */
-      ZEND_REGISTER_RESOURCE(z, value, *(int *)(type->clientdata));
-    } else {
-      /*
-       * Wrap the resource in an object, the resource will be accessible
-       * via the "_cPtr" member. This is currently only used by
-       * directorin typemaps.
-       */
-      zval *resource;
-      zend_class_entry **ce = NULL;
-      const char *type_name = type->name+3; /* +3 so: _p_Foo -> Foo */
-      size_t type_name_len;
-      int result;
-      const char * p;
-
-      /* Namespace__Foo -> Foo */
-      /* FIXME: ugly and goes wrong for classes with __ in their names. */
-      while ((p = strstr(type_name, "__")) != NULL) {
-        type_name = p + 2;
-      }
-      type_name_len = strlen(type_name);
-
-      MAKE_STD_ZVAL(resource);
-      ZEND_REGISTER_RESOURCE(resource, value, *(int *)(type->clientdata));
-      if (SWIG_PREFIX_LEN > 0) {
-        char * classname = (char*)emalloc(SWIG_PREFIX_LEN + type_name_len + 1);
-        strcpy(classname, SWIG_PREFIX);
-        strcpy(classname + SWIG_PREFIX_LEN, type_name);
-        result = zend_lookup_class(classname, SWIG_PREFIX_LEN + type_name_len, &ce TSRMLS_CC);
-        efree(classname);
-      } else {
-        result = zend_lookup_class((char *)type_name, type_name_len, &ce TSRMLS_CC);
-      }
-      if (result != SUCCESS) {
-        /* class does not exist */
-        object_init(z);
-      } else {
-        object_init_ex(z, *ce);
-      }
-      Z_SET_REFCOUNT_P(z, 1);
-      Z_SET_ISREF_P(z);
-      zend_hash_update(HASH_OF(z), (char*)"_cPtr", sizeof("_cPtr"), (void*)&resource, sizeof(zval), NULL);
-    }
-    return;
-  }
-  zend_error(E_ERROR, "Type: %s not registered with zend",type->name);
-}
-
-/* This pointer conversion routine takes the native pointer p (along with
-   its type name) and converts it by calling appropriate casting functions
-   according to ty.  The resultant pointer is returned, or NULL is returned
-   if the pointer can't be cast.
-
-   Sadly PHP has no API to find a type name from a type id, only from an
-   instance of a resource of the type id, so we have to pass type_name as well.
-
-   The two functions which might call this are:
-   SWIG_ZTS_ConvertResourcePtr which gets the type name from the resource
-   and the registered zend destructors for which we have one per type each
-   with the type name hard wired in. */
-static void *
-SWIG_ZTS_ConvertResourceData(void * p, const char *type_name, swig_type_info *ty TSRMLS_DC) {
-  swig_cast_info *tc;
-  void *result = 0;
-
-  if (!ty) {
-    /* They don't care about the target type, so just pass on the pointer! */
-    return p;
-  }
-
-  if (! type_name) {  
-    /* can't convert p to ptr type ty if we don't know what type p is */
-    return NULL;
-  }
-
-  /* convert and cast p from type_name to ptr as ty. */
-  tc = SWIG_TypeCheck(type_name, ty);
-  if (tc) {
-    int newmemory = 0;
-    result = SWIG_TypeCast(tc, p, &newmemory);
-    assert(!newmemory); /* newmemory handling not yet implemented */
-  }
-  return result;
-}
-
-/* This function returns a pointer of type ty by extracting the pointer
-   and type info from the resource in z.  z must be a resource.
-   If it fails, NULL is returned.
-   It uses SWIG_ZTS_ConvertResourceData to do the real work. */
-static void *
-SWIG_ZTS_ConvertResourcePtr(zval *z, swig_type_info *ty, int flags TSRMLS_DC) {
-  swig_object_wrapper *value;
-  void *p;
-  int type;
-  const char *type_name;
-
-  value = (swig_object_wrapper *) zend_list_find(z->value.lval, &type);
-  if (type==-1) return NULL;
-  if (flags & SWIG_POINTER_DISOWN) {
-    value->newobject = 0;
-  }
-  p = value->ptr;
-
-  type_name=zend_rsrc_list_get_rsrc_type(z->value.lval TSRMLS_CC);
-
-  return SWIG_ZTS_ConvertResourceData(p, type_name, ty TSRMLS_CC);
-}
-
-/* We allow passing of a RESOURCE pointing to the object or an OBJECT whose
-   _cPtr is a resource pointing to the object */
-static int
-SWIG_ZTS_ConvertPtr(zval *z, void **ptr, swig_type_info *ty, int flags TSRMLS_DC) {
-  if (z == NULL) {
-    *ptr = 0;
-    return 0;
-  }
-
-  switch (z->type) {
-    case IS_OBJECT: {
-      zval ** _cPtr;
-      if (zend_hash_find(HASH_OF(z),(char*)"_cPtr",sizeof("_cPtr"),(void**)&_cPtr)==SUCCESS) {
-	if ((*_cPtr)->type==IS_RESOURCE) {
-	  *ptr = SWIG_ZTS_ConvertResourcePtr(*_cPtr, ty, flags TSRMLS_CC);
-	  return (*ptr == NULL ? -1 : 0);
-	}
-      }
-      break;
-    }
-    case IS_RESOURCE:
-      *ptr = SWIG_ZTS_ConvertResourcePtr(z, ty, flags TSRMLS_CC);
-      return (*ptr == NULL ? -1 : 0);
-    case IS_NULL:
-      *ptr = 0;
-      return 0;
-  }
-
-  return -1;
-}
-
-static char const_name[] = "swig_runtime_data_type_pointer";
-static swig_module_info *SWIG_Php_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
-  zval *pointer;
-  swig_module_info *ret = 0;
-
-  MAKE_STD_ZVAL(pointer);
-
-  TSRMLS_FETCH();
-
-  if (zend_get_constant(const_name, sizeof(const_name) - 1, pointer TSRMLS_CC)) {
-    if (pointer->type == IS_LONG) {
-      ret = (swig_module_info *) pointer->value.lval;
-    }
-  } 
-  FREE_ZVAL(pointer);
-  return ret; 
-}
-
-static void SWIG_Php_SetModule(swig_module_info *pointer) {
-  TSRMLS_FETCH();
-  REGISTER_MAIN_LONG_CONSTANT(const_name, (long) pointer, 0);
-}
diff --git a/share/swig/2.0.11/php/std_string.i b/share/swig/2.0.11/php/std_string.i
deleted file mode 100644
index 10d7fdd..0000000
--- a/share/swig/2.0.11/php/std_string.i
+++ /dev/null
@@ -1,79 +0,0 @@
-/* -----------------------------------------------------------------------------
- * std_string.i
- *
- * SWIG typemaps for std::string types
- * ----------------------------------------------------------------------------- */
-
-// ------------------------------------------------------------------------
-// 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>
-
-%{
-#include <string>
-%}
-
-namespace std {
-
-    %naturalvar string;
-
-    class string;
-
-    %typemap(typecheck,precedence=SWIG_TYPECHECK_STRING) string, const string& %{
-        $1 = ( Z_TYPE_PP($input) == IS_STRING ) ? 1 : 0;
-    %}
-
-    %typemap(in) string %{
-        convert_to_string_ex($input);
-        $1.assign(Z_STRVAL_PP($input), Z_STRLEN_PP($input));
-    %}
-
-    %typemap(directorout) string %{
-        convert_to_string_ex($input);
-        $result.assign(Z_STRVAL_PP($input), Z_STRLEN_PP($input));
-    %}
-
-    %typemap(out) string %{
-        ZVAL_STRINGL($result, const_cast<char*>($1.data()), $1.size(), 1);
-    %}
-
-    %typemap(directorin) string, const string& %{
-        ZVAL_STRINGL($input, const_cast<char*>($1.data()), $1.size(), 1);
-    %}
-
-    %typemap(out) const string & %{
-        ZVAL_STRINGL($result, const_cast<char*>($1->data()), $1->size(), 1);
-    %}
-
-    %typemap(throws) string, const string& %{
-        zend_throw_exception(NULL, const_cast<char*>($1.c_str()), 0 TSRMLS_CC);
-        return;
-    %}
-
-    /* These next two handle a function which takes a non-const reference to
-     * a std::string and modifies the string. */
-    %typemap(in) string & ($*1_ltype temp) %{
-        convert_to_string_ex($input);
-        temp.assign(Z_STRVAL_PP($input), Z_STRLEN_PP($input));
-        $1 = &temp;
-    %}
-
-    %typemap(directorout) string & ($*1_ltype *temp) %{
-        convert_to_string_ex($input);
-        temp = new $*1_ltype(Z_STRVAL_PP($input), Z_STRLEN_PP($input));
-        swig_acquire_ownership(temp);
-        $result = temp;
-    %}
-
-    %typemap(argout) string & %{
-	ZVAL_STRINGL(*($input), const_cast<char*>($1->data()), $1->size(), 1);
-    %}
-
-    /* SWIG will apply the non-const typemap above to const string& without
-     * this more specific typemap. */
-    %typemap(argout) const string & "";
-}
diff --git a/share/swig/2.0.11/php/std_vector.i b/share/swig/2.0.11/php/std_vector.i
deleted file mode 100644
index 28c9921..0000000
--- a/share/swig/2.0.11/php/std_vector.i
+++ /dev/null
@@ -1,102 +0,0 @@
-/* -----------------------------------------------------------------------------
- * std_vector.i
- * ----------------------------------------------------------------------------- */
-
-%include <std_common.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);
-    void clear();
-    %rename(push) push_back;
-    void push_back(const value_type& x);
-    %extend {
-      bool is_empty() const {
-        return $self->empty();
-      }
-      T pop() throw (std::out_of_range) {
-        if (self->size() == 0)
-          throw std::out_of_range("pop from empty vector");
-        T x = self->back();
-        self->pop_back();
-        return x;
-      }
-      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);
-    void clear();
-    %rename(push) push_back;
-    void push_back(const value_type& x);
-    %extend {
-      bool is_empty() const {
-        return $self->empty();
-      }
-      bool pop() throw (std::out_of_range) {
-        if (self->size() == 0)
-          throw std::out_of_range("pop from empty vector");
-        bool x = self->back();
-        self->pop_back();
-        return x;
-      }
-      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");
-      }
-    }
-  };
-}
-
-%define specialize_std_vector(T)
-#warning "specialize_std_vector - specialization for type T no longer needed"
-%enddef
-
-
diff --git a/share/swig/2.0.11/php/typemaps.i b/share/swig/2.0.11/php/typemaps.i
deleted file mode 100644
index 9fd73fe..0000000
--- a/share/swig/2.0.11/php/typemaps.i
+++ /dev/null
@@ -1,322 +0,0 @@
-/* -----------------------------------------------------------------------------
- * typemaps.i.
- *
- * SWIG Typemap library for PHP.
- *
- * This library provides standard typemaps for modifying SWIG's behavior.
- * With enough entries in this file, I hope that very few people actually
- * ever need to write a typemap.
- *
- * Define macros to define the following typemaps:
- *
- * TYPE *INPUT.   Argument is passed in as native variable by value.
- * TYPE *OUTPUT.  Argument is returned as an array from the function call.
- * TYPE *INOUT.   Argument is passed in by value, and out as part of returned list
- * TYPE *REFERENCE.  Argument is passed in as native variable with value
- *                   semantics.  Variable value is changed with result.
- *                   Use like this:
- *                   int foo(int *REFERENCE);
- *
- *                   $a = 0;
- *                   $rc = foo($a);
- *
- *                   Even though $a looks like it's passed by value,
- *                   its value can be changed by foo().
- * ----------------------------------------------------------------------------- */
-
-%define BOOL_TYPEMAP(TYPE)
-%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
-%{
-  convert_to_boolean_ex($input);
-  temp = Z_LVAL_PP($input) ? true : false;
-  $1 = &temp;
-%}
-%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
-%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
-%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
-{
-  zval *o;
-  MAKE_STD_ZVAL(o);
-  ZVAL_BOOL(o,temp$argnum);
-  t_output_helper( &$result, o );
-}
-%typemap(in) TYPE *REFERENCE (TYPE lvalue), TYPE &REFERENCE (TYPE lvalue)
-%{
-  convert_to_boolean_ex($input);
-  lvalue = (*$input)->value.lval ? true : false;
-  $1 = &lvalue;
-%}
-%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
-%{
-  (*$arg)->value.lval = lvalue$argnum ? true : false;
-  (*$arg)->type = IS_BOOL;
-%}
-%enddef
-
-%define DOUBLE_TYPEMAP(TYPE)
-%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
-%{
-  convert_to_double_ex($input);
-  temp = (TYPE) Z_DVAL_PP($input);
-  $1 = &temp;
-%}
-%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
-%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
-%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
-{
-  zval *o;
-  MAKE_STD_ZVAL(o);
-  ZVAL_DOUBLE(o,temp$argnum);
-  t_output_helper( &$result, o );
-}
-%typemap(in) TYPE *REFERENCE (TYPE dvalue), TYPE &REFERENCE (TYPE dvalue)
-%{
-  convert_to_double_ex($input);
-  dvalue = (TYPE) (*$input)->value.dval;
-  $1 = &dvalue;
-%}
-%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
-%{
-  $1->value.dval = (double)(lvalue$argnum);
-  $1->type = IS_DOUBLE;
-%}
-%enddef
-
-%define INT_TYPEMAP(TYPE)
-%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
-%{
-  convert_to_long_ex($input);
-  temp = (TYPE) Z_LVAL_PP($input);
-  $1 = &temp;
-%}
-%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
-%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
-%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
-{
-  zval *o;
-  MAKE_STD_ZVAL(o);
-  ZVAL_LONG(o,temp$argnum);
-  t_output_helper( &$result, o );
-}
-%typemap(in) TYPE *REFERENCE (TYPE lvalue), TYPE &REFERENCE (TYPE lvalue)
-%{
-  convert_to_long_ex($input);
-  lvalue = (TYPE) (*$input)->value.lval;
-  $1 = &lvalue;
-%}
-%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
-%{
-  (*$arg)->value.lval = (long)(lvalue$argnum);
-  (*$arg)->type = IS_LONG;
-%}
-%enddef
-
-BOOL_TYPEMAP(bool);
-
-DOUBLE_TYPEMAP(float);
-DOUBLE_TYPEMAP(double);
-
-INT_TYPEMAP(int);
-INT_TYPEMAP(short);
-INT_TYPEMAP(long);
-INT_TYPEMAP(unsigned int);
-INT_TYPEMAP(unsigned short);
-INT_TYPEMAP(unsigned long);
-INT_TYPEMAP(unsigned char);
-INT_TYPEMAP(signed char);
-
-INT_TYPEMAP(long long);
-%typemap(argout,fragment="t_output_helper") long long *OUTPUT
-{
-  zval *o;
-  MAKE_STD_ZVAL(o);
-  if ((long long)LONG_MIN <= temp$argnum && temp$argnum <= (long long)LONG_MAX) {
-    ZVAL_LONG(o, temp$argnum);
-  } else {
-    char temp[256];
-    sprintf(temp, "%lld", (long long)temp$argnum);
-    ZVAL_STRING(o, temp, 1);
-  }
-  t_output_helper( &$result, o );
-}
-%typemap(in) TYPE *REFERENCE (long long lvalue)
-%{
-  CONVERT_LONG_LONG_IN(lvalue, long long, $input)
-  $1 = &lvalue;
-%}
-%typemap(argout) long long *REFERENCE
-%{
-  if ((long long)LONG_MIN <= lvalue$argnum && lvalue$argnum <= (long long)LONG_MAX) {
-    (*$arg)->value.lval = (long)(lvalue$argnum);
-    (*$arg)->type = IS_LONG;
-  } else {
-    char temp[256];
-    sprintf(temp, "%lld", (long long)lvalue$argnum);
-    ZVAL_STRING((*$arg), temp, 1);
-  }
-%}
-%typemap(argout) long long &OUTPUT
-%{
-  if ((long long)LONG_MIN <= *arg$argnum && *arg$argnum <= (long long)LONG_MAX) {
-    ($result)->value.lval = (long)(*arg$argnum);
-    ($result)->type = IS_LONG;
-  } else {
-    char temp[256];
-    sprintf(temp, "%lld", (long long)(*arg$argnum));
-    ZVAL_STRING($result, temp, 1);
-  }
-%}
-INT_TYPEMAP(unsigned long long);
-%typemap(argout,fragment="t_output_helper") unsigned long long *OUTPUT
-{
-  zval *o;
-  MAKE_STD_ZVAL(o);
-  if (temp$argnum <= (unsigned long long)LONG_MAX) {
-    ZVAL_LONG(o, temp$argnum);
-  } else {
-    char temp[256];
-    sprintf(temp, "%llu", (unsigned long long)temp$argnum);
-    ZVAL_STRING(o, temp, 1);
-  }
-  t_output_helper( &$result, o );
-}
-%typemap(in) TYPE *REFERENCE (unsigned long long lvalue)
-%{
-  CONVERT_UNSIGNED_LONG_LONG_IN(lvalue, unsigned long long, $input)
-  $1 = &lvalue;
-%}
-%typemap(argout) unsigned long long *REFERENCE
-%{
-  if (lvalue$argnum <= (unsigned long long)LONG_MAX) {
-    (*$arg)->value.lval = (long)(lvalue$argnum);
-    (*$arg)->type = IS_LONG;
-  } else {
-    char temp[256];
-    sprintf(temp, "%llu", (unsigned long long)lvalue$argnum);
-    ZVAL_STRING((*$arg), temp, 1);
-  }
-%}
-%typemap(argout) unsigned long long &OUTPUT
-%{
-  if (*arg$argnum <= (unsigned long long)LONG_MAX) {
-    ($result)->value.lval = (long)(*arg$argnum);
-    ($result)->type = IS_LONG;
-  } else {
-    char temp[256];
-    sprintf(temp, "%llu", (unsigned long long)(*arg$argnum));
-    ZVAL_STRING($result, temp, 1);
-  }
-%}
-
-%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) 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 char *INOUT = unsigned char *INPUT;
-%typemap(in) unsigned long long *INOUT = unsigned long long *INPUT;
-%typemap(in) signed char *INOUT = signed 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) short &INOUT = short *INPUT;
-%typemap(in) long &INOUT = long *INPUT;
-%typemap(in) long long &INOUT = long long *INPUT;
-%typemap(in) long long &INPUT = 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 char &INOUT = unsigned char *INPUT;
-%typemap(in) unsigned long long &INOUT = unsigned long long *INPUT;
-%typemap(in) unsigned long long &INPUT = unsigned long long *INPUT;
-%typemap(in) signed char &INOUT = signed char *INPUT;
-
-%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) short *INOUT = short *OUTPUT;
-%typemap(argout) long *INOUT= long *OUTPUT;
-%typemap(argout) long long *INOUT= long long *OUTPUT;
-%typemap(argout) unsigned short *INOUT= unsigned short *OUTPUT;
-%typemap(argout) unsigned long *INOUT = unsigned long *OUTPUT;
-%typemap(argout) unsigned char *INOUT = unsigned char *OUTPUT;
-%typemap(argout) unsigned long long *INOUT = unsigned long long *OUTPUT;
-%typemap(argout) signed char *INOUT = signed 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) short &INOUT = short *OUTPUT;
-%typemap(argout) long &INOUT= long *OUTPUT;
-%typemap(argout) long long &INOUT= long long *OUTPUT;
-%typemap(argout) unsigned short &INOUT= unsigned short *OUTPUT;
-%typemap(argout) unsigned long &INOUT = unsigned long *OUTPUT;
-%typemap(argout) unsigned char &INOUT = unsigned char *OUTPUT;
-%typemap(argout) unsigned long long &INOUT = unsigned long long *OUTPUT;
-%typemap(argout) signed char &INOUT = signed char *OUTPUT;
-
-%typemap(in) char INPUT[ANY] ( char temp[$1_dim0] )
-%{
-  convert_to_string_ex($input);
-  strncpy(temp,Z_LVAL_PP($input),$1_dim0);
-  $1 = temp;
-%}
-%typemap(in,numinputs=0) char OUTPUT[ANY] ( char temp[$1_dim0] )
-  "$1 = temp;";
-%typemap(argout) char OUTPUT[ANY]
-{
-  zval *o;
-  MAKE_STD_ZVAL(o);
-  ZVAL_STRINGL(o,temp$argnum,$1_dim0);
-  t_output_helper( &$result, o );
-}
-
-%typemap(in,numinputs=0) void **OUTPUT (int force),
-                         void *&OUTPUT (int force)
-%{
-  /* If they pass NULL by reference, make it into a void*
-     This bit should go in arginit if arginit support init-ing scripting args */
-  if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0) {
-    /* So... we didn't get a ref or ptr, but we'll accept NULL by reference */
-    if (!((*$input)->type==IS_NULL && PZVAL_IS_REF(*$input))) {
-      /* wasn't a pre/ref/thing, OR anything like an int thing */
-      SWIG_PHP_Error(E_ERROR, "Type error in argument $arg of $symname.");
-    }
-  }
-  force=0;
-  if (arg1==NULL) {
-#ifdef __cplusplus
-    ptr=new $*1_ltype;
-#else
-    ptr=($*1_ltype) calloc(1,sizeof($*1_ltype));
-#endif
-    $1=&ptr;
-    /* have to passback arg$arg too */
-    force=1;
-  }
-%}
-
-%typemap(argout) void **OUTPUT,
-                 void *&OUTPUT
-%{
-  if (force$argnum) {  /* pass back arg$argnum through params ($arg) if we can */
-    if (!PZVAL_IS_REF(*$arg)) {
-      SWIG_PHP_Error(E_WARNING, "Parameter $argnum of $symname wasn't passed by reference");
-    } else {
-      SWIG_SetPointerZval(*$arg, (void *) ptr$argnum, $*1_descriptor, 1);
-    }
-  }
-%}
diff --git a/share/swig/2.0.11/php/utils.i b/share/swig/2.0.11/php/utils.i
deleted file mode 100644
index 07ac969..0000000
--- a/share/swig/2.0.11/php/utils.i
+++ /dev/null
@@ -1,114 +0,0 @@
-
-%define CONVERT_BOOL_IN(lvar,t,invar)
-  convert_to_boolean_ex(invar);
-  lvar = (t) Z_LVAL_PP(invar);
-%enddef
-
-%define CONVERT_INT_IN(lvar,t,invar)
-  convert_to_long_ex(invar);
-  lvar = (t) Z_LVAL_PP(invar);
-%enddef
-
-%define CONVERT_LONG_LONG_IN(lvar,t,invar)
-  switch ((*(invar))->type) {
-      case IS_DOUBLE:
-          lvar = (t) (*(invar))->value.dval;
-          break;
-      case IS_STRING: {
-          char * endptr;
-          errno = 0;
-          lvar = (t) strtoll((*(invar))->value.str.val, &endptr, 10);
-          if (*endptr && !errno) break;
-          /* FALL THRU */
-      }
-      default:
-          convert_to_long_ex(invar);
-          lvar = (t) (*(invar))->value.lval;
-  }
-%enddef
-
-%define CONVERT_UNSIGNED_LONG_LONG_IN(lvar,t,invar)
-  switch ((*(invar))->type) {
-      case IS_DOUBLE:
-          lvar = (t) (*(invar))->value.dval;
-          break;
-      case IS_STRING: {
-          char * endptr;
-          errno = 0;
-          lvar = (t) strtoull((*(invar))->value.str.val, &endptr, 10);
-          if (*endptr && !errno) break;
-          /* FALL THRU */
-      }
-      default:
-          convert_to_long_ex(invar);
-          lvar = (t) (*(invar))->value.lval;
-  }
-%enddef
-
-%define CONVERT_INT_OUT(lvar,invar)
-  lvar = (t) Z_LVAL_PP(invar);
-%enddef
-
-%define CONVERT_FLOAT_IN(lvar,t,invar)
-  convert_to_double_ex(invar);
-  lvar = (t) Z_DVAL_PP(invar);
-%enddef
-
-%define CONVERT_CHAR_IN(lvar,t,invar)
-  convert_to_string_ex(invar);
-  lvar = (t) *Z_STRVAL_PP(invar);
-%enddef
-
-%define CONVERT_STRING_IN(lvar,t,invar)
-  if ((*invar)->type==IS_NULL) {
-    lvar = (t) 0;
-  } else {
-    convert_to_string_ex(invar);
-    lvar = (t) Z_STRVAL_PP(invar);
-  }
-%enddef
-
-%define %pass_by_val( TYPE, CONVERT_IN )
-%typemap(in) TYPE
-%{
-  CONVERT_IN($1,$1_ltype,$input);
-%}
-%typemap(in) const TYPE & ($*1_ltype temp)
-%{
-  CONVERT_IN(temp,$*1_ltype,$input);
-  $1 = &temp;
-%}
-%typemap(directorout) TYPE
-%{
-  CONVERT_IN($result,$1_ltype,$input);
-%}
-%typemap(directorout) const TYPE & ($*1_ltype temp)
-%{
-  CONVERT_IN(temp,$*1_ltype,$input);
-  $result = &temp;
-%}
-%enddef
-
-%fragment("t_output_helper","header") %{
-static void
-t_output_helper( zval **target, zval *o) {
-  if ( (*target)->type == IS_ARRAY ) {
-    /* it's already an array, just append */
-    add_next_index_zval( *target, o );
-    return;
-  }
-  if ( (*target)->type == IS_NULL ) {
-    REPLACE_ZVAL_VALUE(target,o,1);
-    FREE_ZVAL(o);
-    return;
-  }
-  zval *tmp;
-  ALLOC_INIT_ZVAL(tmp);
-  *tmp = **target;
-  zval_copy_ctor(tmp);
-  array_init(*target);
-  add_next_index_zval( *target, tmp);
-  add_next_index_zval( *target, o);
-
-}
-%}
diff --git a/share/swig/2.0.11/pike/pike.swg b/share/swig/2.0.11/pike/pike.swg
deleted file mode 100644
index 399752a..0000000
--- a/share/swig/2.0.11/pike/pike.swg
+++ /dev/null
@@ -1,320 +0,0 @@
-/* -----------------------------------------------------------------------------
- * pike.swg
- *
- * Pike configuration module.
- * ----------------------------------------------------------------------------- */
-
-%insert(runtime) "swigrun.swg";            // Common C API type-checking code
-%insert(runtime) "pikerun.swg";         // Pike run-time code
-
-%insert(runtime) %{
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include <pike/global.h>
-#include <pike/module.h>
-#include <pike/interpret.h>
-#ifdef __cplusplus
-}
-#endif
-%}
-
-/* -----------------------------------------------------------------------------
- *                          standard typemaps
- * ----------------------------------------------------------------------------- */
-
-/* --- Input arguments --- */
-
-/* Primitive datatypes. */
-
-%typemap(in, pikedesc="tInt")
-    int, unsigned int, short, unsigned short,
-    long, unsigned long, char, signed char, unsigned char,
-    bool, enum SWIGTYPE, long long, unsigned long long
-{
-    if ($input.type != T_INT)
-        Pike_error("Bad argument: Expected an integer.\n");
-    $1 = ($1_ltype) $input.u.integer;
-}
-
-%typemap(in, pikedesc="tFloat") float, double {
-    if ($input.type != T_FLOAT)
-        Pike_error("Bad argument: Expected a float.\n");
-    $1 = ($1_ltype) $input.u.float_number;
-}
-
-%typemap(in, pikedesc="tStr") char *, char [ANY] {
-    if ($input.type != T_STRING)
-        Pike_error("Bad argument: Expected a string.\n");
-    $1 = ($1_ltype) STR0($input.u.string);
-}
-
-/* Pointers, references and arrays */
-
-%typemap(in) SWIGTYPE *,
-             SWIGTYPE &,
-             SWIGTYPE []
-	"SWIG_ConvertPtr($input.u.object, (void **) &$1, $1_descriptor, 1);"
-	
-/* Void pointer.  Accepts any kind of pointer */
-%typemap(in) void * "/* FIXME */";
-
-/* Object passed by value. Convert to a pointer */
-%typemap(in) SWIGTYPE ($&1_ltype argp) "/* FIXME */";
-
-/* Pointer to a class member */
-%typemap(in) SWIGTYPE (CLASS::*) "/* FIXME */";
-
-/* Const primitive references.  Passed by value */
-
-%typemap(in, pikedesc="tInt") const int & (int temp),
-	     const short & (short temp),
-             const long  & (long temp),
-             const unsigned int & (unsigned int temp),
-             const unsigned short & (unsigned short temp),
-             const unsigned long & (unsigned long temp),
-	     const char & (char temp),
-             const signed char & (signed char temp),
-             const unsigned char & (unsigned char temp),
-             const bool & (bool temp),
-	     const long long & ($*1_ltype temp),
-	     const unsigned long long & ($*1_ltype temp),
-             const enum SWIGTYPE & ($*1_ltype temp)
-{
-  if ($input.type != T_INT)
-    Pike_error("Bad argument: Expected an integer.\n");
-    temp = ($*1_ltype) $input.u.integer;
-    $1 = &temp;
-}
-
-%typemap(in, pikedesc="tFloat") const float & (float temp),
-	     const double & (double temp)
-{
-  if ($input.type != T_FLOAT)
-    Pike_error("Bad argument: Expected a float.\n");
-    temp = ($*1_ltype) $input.u.float_number;
-    $1 = &temp;
-}
-
-/* -----------------------------------------------------------------------------
- * Output Typemaps
- * ----------------------------------------------------------------------------- */
-%typemap(out, pikedesc="tInt")
-    int, unsigned int,
-    short, unsigned short,
-    long, unsigned long,
-    char, signed char, unsigned char, 
-    bool, enum SWIGTYPE
-	"push_int($1);";
-
-%typemap(out, pikedesc="tInt") long long	"push_int64($1);";
-%typemap(out, pikedesc="tInt") unsigned long long	"push_int64($1);";
-%typemap(out, pikedesc="tFloat") float, double	"push_float($1);";
-%typemap(out, pikedesc="tStr") char *		"push_text($1);";
-
-/* Pointers, references, and arrays */
-%typemap(out, pikedesc="tObj") SWIGTYPE*, SWIGTYPE &, SWIGTYPE [] "push_object(SWIG_NewPointerObj((void *) $1, $1_descriptor, $owner));";
-
-/* Void return value; don't push anything */
-%typemap(out, pikedesc="tVoid") void		"";
-
-/* Dynamic casts */
-
-%typemap(out) SWIGTYPE *DYNAMIC, SWIGTYPE &DYNAMIC "/* FIXME */";
-
-/* Member pointer */
-%typemap(out) SWIGTYPE (CLASS::*) "/* FIXME */";
-
-/* Special typemap for character array return values */
-%typemap(out, pikedesc="tStr") char [ANY], const char [ANY] "push_text($1);";
-
-/* Primitive types--return by value */
-%typemap(out, pikedesc="tObj") SWIGTYPE 
-#ifdef __cplusplus
-{
-  $&1_ltype resultptr;
-  resultptr = new $1_ltype((const $1_ltype &) $1);
-  push_object(SWIG_NewPointerObj((void *) resultptr, $&1_descriptor, 1));
-}
-#else
-{
-  $&1_ltype resultptr;
-  resultptr = ($&1_ltype) malloc(sizeof($1_type));
-  memmove(resultptr, &$1, sizeof($1_type));
-  push_object(SWIG_NewPointerObj((void *) resultptr, $&1_descriptor, 1));
-}
-#endif
-
-/* References to primitive types.  Return by value */
-
-%typemap(out, pikedesc="tInt") const int &, const unsigned int &,
-              const short &, const unsigned short &,
-              const long &, const unsigned long &,
-              const char &, const signed char &, const unsigned char &,
-              const bool &,
-	      const long long &, const unsigned long long &,
-              const enum SWIGTYPE & ($*1_ltype temp)
-      "push_int(*($1));";
-
-%typemap(out, pikedesc="tFloat") const float &, const double &  "push_float(*($1));";
-
-/************************ Constant Typemaps *****************************/
-
-%typemap(constant)
-    int, unsigned int,
-    short, unsigned short,
-    long, unsigned long,
-    signed char, unsigned char, 
-    bool, enum SWIGTYPE,
-    long long, unsigned long long
-    	"add_integer_constant(\"$symname\", $1, 0);";
-
-%typemap(constant) char
-	"add_integer_constant(\"$symname\", '$1', 0);";
-
-%typemap(constant) long long, unsigned long long
-	"add_integer_constant(\"$symname\", $1, 0);";
-
-%typemap(constant) float, double
-	"add_float_constant(\"$symname\", $1, 0);";
-
-%typemap(constant) char *
-	"add_string_constant(\"$symname\", \"$1\", 0);";
-
-/* ------------------------------------------------------------
- * String & length
- * ------------------------------------------------------------ */
-
-%typemap(in) (char *STRING, int LENGTH), (char *STRING, size_t LENGTH) {
-    if ($input.type != T_STRING)
-        Pike_error("Bad argument: Expected a string.\n");
-    $1 = ($1_ltype) STR0($input.u.string);
-    $2 = ($2_ltype) $input.u.string->length;
-}
-
-/* ------------------------------------------------------------
- * ANSI C typemaps
- * ------------------------------------------------------------ */
-
-%typemap(in, pikedesc="tInt") size_t {
-    if ($input.type != T_INT)
-        Pike_error("Bad argument: Expected an integer.\n");
-    $1 = ($1_ltype) $input.u.integer;
-}
-
-%typemap(out)      size_t = long;
-
-/* ------------------------------------------------------------
- * Typechecking rules
- * ------------------------------------------------------------ */
-
-%typecheck(SWIG_TYPECHECK_INTEGER)
-	 int, short, long,
- 	 unsigned int, unsigned short, unsigned long,
-	 signed char, unsigned char,
-	 long long, unsigned long long,
-	 const int &, const short &, const long &,
- 	 const unsigned int &, const unsigned short &, const unsigned long &,
-	 const long long &, const unsigned long long &,
-	 enum SWIGTYPE, enum SWIGTYPE &,
-         bool, const bool & 
-{
-  $1 = ($input.type == T_INT) ? 1 : 0;
-}
-
-%typecheck(SWIG_TYPECHECK_DOUBLE)
-	float, double,
-	const float &, const double &
-{
-  $1 = (($input.type == T_FLOAT) || ($input.type == T_INT)) ? 1 : 0;
-}
-
-%typecheck(SWIG_TYPECHECK_CHAR) char {
-  $1 = ($input.type == T_INT) ? 1 : 0;
-}
-
-%typecheck(SWIG_TYPECHECK_STRING) char * {
-  $1 = ($input.type == T_STRING) ? 1 : 0;
-}
-
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
-  void *ptr;
-  if (SWIG_ConvertPtr($input.u.object, (void **) &ptr, $1_descriptor, 0) == -1) {
-    $1 = 0;
-  } else {
-    $1 = 1;
-  }
-}
-
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE {
-  void *ptr;
-  if (SWIG_ConvertPtr($input.u.object, (void **) &ptr, $&1_descriptor, 0) == -1) {
-    $1 = 0;
-  } else {
-    $1 = 1;
-  }
-}
-
-%typecheck(SWIG_TYPECHECK_VOIDPTR) void * {
-  void *ptr;
-  if (SWIG_ConvertPtr($input.u.object, (void **) &ptr, 0, 0) == -1) {
-    $1 = 0;
-  } else {
-    $1 = 1;
-  }
-}
-
-/* Array reference typemaps */
-%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
-
-/* const pointers */
-%apply SWIGTYPE * { SWIGTYPE *const }
-
-/* ------------------------------------------------------------
- * Overloaded operator support
- * ------------------------------------------------------------ */
-
-#ifdef __cplusplus
-%rename("`+")      *::operator+;
-%rename("`-")      *::operator-;
-%rename("`*")      *::operator*;
-%rename("`/")      *::operator/;
-%rename("`%")      *::operator%;
-%rename("`<<")     *::operator<<;
-%rename("`>>")     *::operator>>;
-%rename("`&")      *::operator&;
-%rename("`|")      *::operator|;
-%rename("`^")      *::operator^;
-%rename("`~")      *::operator~;
-%rename("`<")      *::operator<;
-%rename("`>")      *::operator>;
-%rename("`==")     *::operator==;
-
-/* Special cases */
-%rename("`()")     *::operator();
-
-#endif
-
-/* ------------------------------------------------------------
- * The start of the Pike initialization function
- * ------------------------------------------------------------ */
-
-%init "swiginit.swg"
-
-%init %{
-#ifdef __cplusplus
-extern "C"
-#endif
-PIKE_MODULE_EXIT {}
-
-#ifdef __cplusplus
-extern "C"
-#endif
-PIKE_MODULE_INIT
-{
-    struct program *pr;
-    SWIG_InitializeModule(0);
-%}
-
-/* pike keywords */
-%include <pikekw.swg>
diff --git a/share/swig/2.0.11/pointer.i b/share/swig/2.0.11/pointer.i
deleted file mode 100644
index 8015317..0000000
--- a/share/swig/2.0.11/pointer.i
+++ /dev/null
@@ -1,11 +0,0 @@
-/* -----------------------------------------------------------------------------
- * pointer.i
- * ----------------------------------------------------------------------------- */
-
-
-%echo "pointer.i is deprecated.  Use cpointer.i instead."
-%echo "See http://www.swig.org/Doc1.3/Library.html"
-
-
-
-
diff --git a/share/swig/2.0.11/python/boost_shared_ptr.i b/share/swig/2.0.11/python/boost_shared_ptr.i
deleted file mode 100644
index 100ed3e..0000000
--- a/share/swig/2.0.11/python/boost_shared_ptr.i
+++ /dev/null
@@ -1,322 +0,0 @@
-%include <shared_ptr.i>
-
-// Set SHARED_PTR_DISOWN to $disown if required, for example
-// #define SHARED_PTR_DISOWN $disown
-#if !defined(SHARED_PTR_DISOWN)
-#define SHARED_PTR_DISOWN 0
-#endif
-
-%fragment("SWIG_null_deleter_python", "header", fragment="SWIG_null_deleter") {
-%#define SWIG_NO_NULL_DELETER_SWIG_BUILTIN_INIT
-}
-
-// Language specific macro implementing all the customisations for handling the smart pointer
-%define SWIG_SHARED_PTR_TYPEMAPS(CONST, TYPE...)
-
-// %naturalvar is as documented for member variables
-%naturalvar TYPE;
-%naturalvar SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
-
-// destructor wrapper customisation
-%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) CONST TYPE (void *argp, int res = 0) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (!argp) {
-    %argument_nullref("$type", $symname, $argnum);
-  } else {
-    $1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
-    if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-  }
-}
-%typemap(out) CONST TYPE {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
-  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-%typemap(varin) CONST TYPE {
-  void *argp = 0;
-  int newmem = 0;
-  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res, "$type", "$name");
-  }
-  if (!argp) {
-    %argument_nullref("$type", $symname, $argnum);
-  } else {
-    $1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
-    if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-  }
-}
-%typemap(varout) CONST TYPE {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
-  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-// plain pointer
-// Note: $disown not implemented by default as it will lead to a memory leak of the shared_ptr instance
-%typemap(in) CONST TYPE * (void  *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SHARED_PTR_DISOWN | %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (newmem & SWIG_CAST_NEW_MEMORY) {
-    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    $1 = %const_cast(tempshared.get(), $1_ltype);
-  } else {
-    smartarg = %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
-  }
-}
-
-%typemap(out, fragment="SWIG_null_deleter_python") CONST TYPE * {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner) : 0;
-  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), $owner | SWIG_POINTER_OWN));
-}
-
-%typemap(varin) CONST TYPE * {
-  void *argp = 0;
-  int newmem = 0;
-  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res, "$type", "$name");
-  }
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0;
-  if (newmem & SWIG_CAST_NEW_MEMORY) {
-    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    $1 = %const_cast(tempshared.get(), $1_ltype);
-  } else {
-    smartarg = %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
-  }
-}
-%typemap(varout, fragment="SWIG_null_deleter_python") CONST TYPE * {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_0) : 0;
-  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-// plain reference
-%typemap(in) CONST TYPE & (void  *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (!argp) { %argument_nullref("$type", $symname, $argnum); }
-  if (newmem & SWIG_CAST_NEW_MEMORY) {
-    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    $1 = %const_cast(tempshared.get(), $1_ltype);
-  } else {
-    $1 = %const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
-  }
-}
-%typemap(out, fragment="SWIG_null_deleter_python") CONST TYPE & {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner);
-  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-%typemap(varin) CONST TYPE & {
-  void *argp = 0;
-  int newmem = 0;
-  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res, "$type", "$name");
-  }
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
-  if (!argp) { %argument_nullref("$type", $symname, $argnum); }
-  if (newmem & SWIG_CAST_NEW_MEMORY) {
-    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    $1 = *%const_cast(tempshared.get(), $1_ltype);
-  } else {
-    $1 = *%const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
-  }
-}
-%typemap(varout, fragment="SWIG_null_deleter_python") CONST TYPE & {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(&$1 SWIG_NO_NULL_DELETER_0);
-  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-// plain pointer by reference
-// Note: $disown not implemented by default as it will lead to a memory leak of the shared_ptr instance
-%typemap(in) TYPE *CONST& (void  *argp = 0, int res = 0, $*1_ltype temp = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SHARED_PTR_DISOWN | %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (newmem & SWIG_CAST_NEW_MEMORY) {
-    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    temp = %const_cast(tempshared.get(), $*1_ltype);
-  } else {
-    temp = %const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $*1_ltype);
-  }
-  $1 = &temp;
-}
-%typemap(out, fragment="SWIG_null_deleter_python") TYPE *CONST& {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1 SWIG_NO_NULL_DELETER_$owner);
-  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-%typemap(varin) TYPE *CONST& %{
-#error "varin typemap not implemented"
-%}
-%typemap(varout) TYPE *CONST& %{
-#error "varout typemap not implemented"
-%}
-
-// shared_ptr by value
-%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > (void *argp, int res = 0) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (argp) $1 = *(%reinterpret_cast(argp, $&ltype));
-  if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $&ltype);
-}
-%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
-  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
-  int newmem = 0;
-  void *argp = 0;
-  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res, "$type", "$name");
-  }
-  $1 = argp ? *(%reinterpret_cast(argp, $&ltype)) : SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE >();
-  if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $&ltype);
-}
-%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
-  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-// shared_ptr by reference
-%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & (void *argp, int res = 0, $*1_ltype tempshared) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (newmem & SWIG_CAST_NEW_MEMORY) {
-    if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
-    delete %reinterpret_cast(argp, $ltype);
-    $1 = &tempshared;
-  } else {
-    $1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
-  }
-}
-%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
-  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
-#error "varin typemap not implemented"
-%}
-%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
-#error "varout typemap not implemented"
-%}
-
-// shared_ptr by pointer
-%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * (void *argp, int res = 0, $*1_ltype tempshared) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (newmem & SWIG_CAST_NEW_MEMORY) {
-    if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
-    delete %reinterpret_cast(argp, $ltype);
-    $1 = &tempshared;
-  } else {
-    $1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
-  }
-}
-%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 && *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
-  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-  if ($owner) delete $1;
-}
-
-%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
-#error "varin typemap not implemented"
-%}
-%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
-#error "varout typemap not implemented"
-%}
-
-// shared_ptr by pointer reference
-%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& (void *argp, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, $*1_ltype temp = 0) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (argp) tempshared = *%reinterpret_cast(argp, $*ltype);
-  if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $*ltype);
-  temp = &tempshared;
-  $1 = &temp;
-}
-%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 && **$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(**$1) : 0;
-  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
-#error "varin typemap not implemented"
-%}
-%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
-#error "varout typemap not implemented"
-%}
-
-// Typecheck typemaps
-// Note: SWIG_ConvertPtr with void ** parameter set to 0 instead of using SWIG_ConvertPtrAndOwn, so that the casting 
-// function is not called thereby avoiding a possible smart pointer copy constructor call when casting up the inheritance chain.
-%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1) 
-                      TYPE CONST,
-                      TYPE CONST &,
-                      TYPE CONST *,
-                      TYPE *CONST&,
-                      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 > *& {
-  int res = SWIG_ConvertPtr($input, 0, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), 0);
-  $1 = SWIG_CheckState(res);
-}
-
-
-// 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"
-%}
-
-
-%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
-
-
-%enddef
-
diff --git a/share/swig/2.0.11/python/builtin.swg b/share/swig/2.0.11/python/builtin.swg
deleted file mode 100644
index 28c557a..0000000
--- a/share/swig/2.0.11/python/builtin.swg
+++ /dev/null
@@ -1,514 +0,0 @@
-#define SWIGPY_UNARYFUNC_CLOSURE(wrapper)	\
-SWIGINTERN PyObject *				\
-wrapper##_closure(PyObject *a) {		\
-  return wrapper(a, NULL);			\
-}
-
-#define SWIGPY_DESTRUCTOR_CLOSURE(wrapper)	\
-SWIGINTERN void					\
-wrapper##_closure(PyObject *a) {		\
-    SwigPyObject *sobj;				\
-    sobj = (SwigPyObject *)a;			\
-    if (sobj->own) {				\
-	PyObject *o = wrapper(a, NULL);		\
-	Py_XDECREF(o);				\
-    }						\
-    if (PyType_IS_GC(a->ob_type)) {		\
-	PyObject_GC_Del(a);			\
-    } else {					\
-	PyObject_Del(a);			\
-    }						\
-}
-
-#define SWIGPY_INQUIRY_CLOSURE(wrapper)				\
-SWIGINTERN int							\
-wrapper##_closure(PyObject *a) {				\
-    PyObject *pyresult;						\
-    int result;							\
-    pyresult = wrapper(a, NULL);				\
-    result = pyresult && PyObject_IsTrue(pyresult) ? 1 : 0;	\
-    Py_XDECREF(pyresult);					\
-    return result;						\
-}
-
-#define SWIGPY_BINARYFUNC_CLOSURE(wrapper)	\
-SWIGINTERN PyObject *				\
-wrapper##_closure(PyObject *a, PyObject *b) {	\
-    PyObject *tuple, *result;			\
-    tuple = PyTuple_New(1);			\
-    assert(tuple);				\
-    PyTuple_SET_ITEM(tuple, 0, b);		\
-    Py_XINCREF(b);				\
-    result = wrapper(a, tuple);			\
-    Py_DECREF(tuple);				\
-    return result;				\
-}
-
-typedef ternaryfunc ternarycallfunc;
-
-#define SWIGPY_TERNARYFUNC_CLOSURE(wrapper)			\
-SWIGINTERN PyObject *						\
-wrapper##_closure(PyObject *a, PyObject *b, PyObject *c) {	\
-    PyObject *tuple, *result;					\
-    tuple = PyTuple_New(2);					\
-    assert(tuple);						\
-    PyTuple_SET_ITEM(tuple, 0, b);				\
-    PyTuple_SET_ITEM(tuple, 1, c);				\
-    Py_XINCREF(b);						\
-    Py_XINCREF(c);						\
-    result = wrapper(a, tuple);					\
-    Py_DECREF(tuple);						\
-    return result;						\
-}
-
-#define SWIGPY_TERNARYCALLFUNC_CLOSURE(wrapper)			\
-SWIGINTERN PyObject *						\
-wrapper##_closure(PyObject *callable_object, PyObject *args, PyObject *) {	\
-    return wrapper(callable_object, args);			\
-}
-
-#define SWIGPY_LENFUNC_CLOSURE(wrapper)			\
-SWIGINTERN Py_ssize_t					\
-wrapper##_closure(PyObject *a) {			\
-    PyObject *resultobj;				\
-    Py_ssize_t result;					\
-    resultobj = wrapper(a, NULL);			\
-    result = PyNumber_AsSsize_t(resultobj, NULL);	\
-    Py_DECREF(resultobj);				\
-    return result;					\
-}
-
-#define SWIGPY_SSIZESSIZEARGFUNC_CLOSURE(wrapper)		\
-SWIGINTERN PyObject *						\
-wrapper##_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c) {	\
-    PyObject *tuple, *result;					\
-    tuple = PyTuple_New(2);					\
-    assert(tuple);						\
-    PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));		\
-    PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));		\
-    result = wrapper(a, tuple);					\
-    Py_DECREF(tuple);						\
-    return result;						\
-}
-
-#define SWIGPY_SSIZESSIZEOBJARGPROC_CLOSURE(wrapper)			\
-SWIGINTERN int								\
-wrapper##_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) { \
-    PyObject *tuple, *resultobj;					\
-    int result;								\
-    tuple = PyTuple_New(d ? 3 : 2);					\
-    assert(tuple);							\
-    PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));			\
-    PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));			\
-    if (d) {								\
-        PyTuple_SET_ITEM(tuple, 2, d);					\
-        Py_INCREF(d);							\
-    }									\
-    resultobj = wrapper(a, tuple);					\
-    result = resultobj ? 0 : -1;					\
-    Py_DECREF(tuple);							\
-    Py_XDECREF(resultobj);						\
-    return result;							\
-}
-
-#define SWIGPY_SSIZEARGFUNC_CLOSURE(wrapper)		\
-SWIGINTERN PyObject *					\
-wrapper##_closure(PyObject *a, Py_ssize_t b) {		\
-    PyObject *tuple, *result;				\
-    tuple = PyTuple_New(1);				\
-    assert(tuple);					\
-    PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));	\
-    result = wrapper(a, tuple);				\
-    Py_DECREF(tuple);					\
-    return result;					\
-}
-
-#define SWIGPY_FUNPACK_SSIZEARGFUNC_CLOSURE(wrapper)		\
-SWIGINTERN PyObject *					\
-wrapper##_closure(PyObject *a, Py_ssize_t b) {		\
-    PyObject *arg, *result;				\
-    arg = _PyLong_FromSsize_t(b);			\
-    result = wrapper(a, arg);				\
-    Py_DECREF(arg);					\
-    return result;					\
-}
-
-#define SWIGPY_SSIZEOBJARGPROC_CLOSURE(wrapper)			\
-SWIGINTERN int							\
-wrapper##_closure(PyObject *a, Py_ssize_t b, PyObject *c) {	\
-    PyObject *tuple, *resultobj;				\
-    int result;							\
-    tuple = PyTuple_New(2);					\
-    assert(tuple);						\
-    PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));		\
-    PyTuple_SET_ITEM(tuple, 1, c);				\
-    Py_XINCREF(c);						\
-    resultobj = wrapper(a, tuple);				\
-    result = resultobj ? 0 : -1;				\
-    Py_XDECREF(resultobj);					\
-    Py_DECREF(tuple);						\
-    return result;						\
-}
-
-#define SWIGPY_OBJOBJARGPROC_CLOSURE(wrapper)			\
-SWIGINTERN int							\
-wrapper##_closure(PyObject *a, PyObject *b, PyObject *c) {	\
-    PyObject *tuple, *resultobj;				\
-    int result;							\
-    tuple = PyTuple_New(c ? 2 : 1);				\
-    assert(tuple);						\
-    PyTuple_SET_ITEM(tuple, 0, b);				\
-    Py_XINCREF(b);						\
-    if (c) {							\
-        PyTuple_SET_ITEM(tuple, 1, c);				\
-        Py_XINCREF(c);						\
-    }								\
-    resultobj = wrapper(a, tuple);				\
-    result = resultobj ? 0 : -1;				\
-    Py_XDECREF(resultobj);					\
-    Py_DECREF(tuple);						\
-    return result;						\
-}
-
-#define SWIGPY_REPRFUNC_CLOSURE(wrapper)	\
-SWIGINTERN PyObject *				\
-wrapper##_closure(PyObject *a) {		\
-    return wrapper(a, NULL);			\
-}
-
-#define SWIGPY_HASHFUNC_CLOSURE(wrapper)	\
-SWIGINTERN long					\
-wrapper##_closure(PyObject *a) {		\
-    PyObject *pyresult;				\
-    long result;				\
-    pyresult = wrapper(a, NULL);		\
-    if (!pyresult || !PyLong_Check(pyresult))	\
-	return -1;				\
-    result = PyLong_AsLong(pyresult);		\
-    Py_DECREF(pyresult);			\
-    return result;				\
-}
-
-#define SWIGPY_ITERNEXT_CLOSURE(wrapper)	\
-SWIGINTERN PyObject *				\
-wrapper##_closure(PyObject *a) {		\
-    PyObject *result;				\
-    result = wrapper(a, NULL);			\
-    if (result && result == Py_None) {		\
-	Py_DECREF(result);			\
-	result = NULL;				\
-    }						\
-    return result;				\
-}
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-SWIGINTERN int
-SwigPyBuiltin_BadInit(PyObject *self, PyObject *SWIGUNUSEDPARM(args), PyObject *SWIGUNUSEDPARM(kwds)) {
-  PyErr_Format(PyExc_TypeError, "Cannot create new instances of type '%.300s'", self->ob_type->tp_name);
-  return -1;
-}
-
-SWIGINTERN void
-SwigPyBuiltin_BadDealloc(PyObject *pyobj) {
-  SwigPyObject *sobj;
-  sobj = (SwigPyObject *)pyobj;
-  if (sobj->own) {
-    PyErr_Format(PyExc_TypeError, "Swig detected a memory leak in type '%.300s': no callable destructor found.", pyobj->ob_type->tp_name);
-  }
-}
-
-typedef struct {
-  PyCFunction get;
-  PyCFunction set;
-} SwigPyGetSet;
-
-SWIGINTERN PyObject *
-SwigPyBuiltin_GetterClosure (PyObject *obj, void *closure) {
-  SwigPyGetSet *getset;
-  PyObject *tuple, *result;
-  if (!closure)
-    return SWIG_Py_Void();
-  getset = (SwigPyGetSet *)closure;
-  if (!getset->get)
-    return SWIG_Py_Void();
-  tuple = PyTuple_New(0);
-  assert(tuple);
-  result = (*getset->get)(obj, tuple);
-  Py_DECREF(tuple);
-  return result;
-}
-
-SWIGINTERN PyObject *
-SwigPyBuiltin_FunpackGetterClosure (PyObject *obj, void *closure) {
-  SwigPyGetSet *getset;
-  PyObject *result;
-  if (!closure)
-    return SWIG_Py_Void();
-  getset = (SwigPyGetSet *)closure;
-  if (!getset->get)
-    return SWIG_Py_Void();
-  result = (*getset->get)(obj, NULL);
-  return result;
-}
-
-SWIGINTERN int
-SwigPyBuiltin_SetterClosure (PyObject *obj, PyObject *val, void *closure) {
-  SwigPyGetSet *getset;
-  PyObject *tuple, *result;
-  if (!closure) {
-    PyErr_Format(PyExc_TypeError, "Missing getset closure");
-    return -1;
-  }
-  getset = (SwigPyGetSet *)closure;
-  if (!getset->set) {
-    PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
-    return -1;
-  }
-  tuple = PyTuple_New(1);
-  assert(tuple);
-  PyTuple_SET_ITEM(tuple, 0, val);
-  Py_XINCREF(val);
-  result = (*getset->set)(obj, tuple);
-  Py_DECREF(tuple);
-  Py_XDECREF(result);
-  return result ? 0 : -1;
-}
-
-SWIGINTERN int
-SwigPyBuiltin_FunpackSetterClosure (PyObject *obj, PyObject *val, void *closure) {
-  SwigPyGetSet *getset;
-  PyObject *result;
-  if (!closure) {
-    PyErr_Format(PyExc_TypeError, "Missing getset closure");
-    return -1;
-  }
-  getset = (SwigPyGetSet *)closure;
-  if (!getset->set) {
-    PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
-    return -1;
-  }
-  result = (*getset->set)(obj, val);
-  Py_XDECREF(result);
-  return result ? 0 : -1;
-}
-
-SWIGINTERN void
-SwigPyStaticVar_dealloc(PyDescrObject *descr) {
-  _PyObject_GC_UNTRACK(descr);
-  Py_XDECREF(PyDescr_TYPE(descr));
-  Py_XDECREF(PyDescr_NAME(descr));
-  PyObject_GC_Del(descr);
-}
-
-SWIGINTERN PyObject *
-SwigPyStaticVar_repr(PyGetSetDescrObject *descr) {
-#if PY_VERSION_HEX >= 0x03000000
-
-  return PyUnicode_FromFormat("<class attribute '%S' of type '%s'>", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
-#else
-  return PyString_FromFormat("<class attribute '%s' of type '%s'>", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
-#endif
-}
-
-SWIGINTERN int
-SwigPyStaticVar_traverse(PyObject *self, visitproc visit, void *arg) {
-  PyDescrObject *descr;
-  descr = (PyDescrObject *)self;
-  Py_VISIT((PyObject*) PyDescr_TYPE(descr));
-  return 0;
-}
-
-SWIGINTERN PyObject *
-SwigPyStaticVar_get(PyGetSetDescrObject *descr, PyObject *obj, PyObject *SWIGUNUSEDPARM(type)) {
-  if (descr->d_getset->get != NULL)
-    return descr->d_getset->get(obj, descr->d_getset->closure);
-#if PY_VERSION_HEX >= 0x03000000
-  PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not readable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
-#else
-  PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not readable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
-#endif
-  return NULL;
-}
-
-SWIGINTERN int
-SwigPyStaticVar_set(PyGetSetDescrObject *descr, PyObject *obj, PyObject *value) {
-  if (descr->d_getset->set != NULL)
-    return descr->d_getset->set(obj, value, descr->d_getset->closure);
-#if PY_VERSION_HEX >= 0x03000000
-  PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not writable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
-#else
-  PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not writable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
-#endif
-  return -1;
-}
-
-SWIGINTERN int
-SwigPyObjectType_setattro(PyTypeObject *type, PyObject *name, PyObject *value) {
-  PyObject *attribute;
-  descrsetfunc local_set;
-  attribute = _PyType_Lookup(type, name);
-  if (attribute != NULL) {
-    /* Implement descriptor functionality, if any */
-    local_set = attribute->ob_type->tp_descr_set;
-    if (local_set != NULL)
-      return local_set(attribute, (PyObject *)type, value);
-#if PY_VERSION_HEX >= 0x03000000
-    PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400S'", type->tp_name, name);
-#else 
-    PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400s'", type->tp_name, PyString_AS_STRING(name));
-#endif
-  } else {
-#if PY_VERSION_HEX >= 0x03000000
-    PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400S'", type->tp_name, name);
-#else
-    PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400s'", type->tp_name, PyString_AS_STRING(name));
-#endif
-  }
-
-  return -1;
-}
-
-SWIGINTERN PyTypeObject*
-SwigPyStaticVar_Type(void) {
-  static PyTypeObject staticvar_type;
-  static int type_init = 0;
-  if (!type_init) {
-    const PyTypeObject tmp = {
-      /* PyObject header changed in Python 3 */
-#if PY_VERSION_HEX >= 0x03000000
-      PyVarObject_HEAD_INIT(&PyType_Type, 0)
-#else
-      PyObject_HEAD_INIT(&PyType_Type)
-      0,
-#endif
-      "swig_static_var_getset_descriptor",
-      sizeof(PyGetSetDescrObject),
-      0,
-      (destructor)SwigPyStaticVar_dealloc,      /* tp_dealloc */
-      0,                                        /* tp_print */
-      0,                                        /* tp_getattr */
-      0,                                        /* tp_setattr */
-      0,                                        /* tp_compare */
-      (reprfunc)SwigPyStaticVar_repr,           /* tp_repr */
-      0,                                        /* tp_as_number */
-      0,                                        /* tp_as_sequence */
-      0,                                        /* tp_as_mapping */
-      0,                                        /* tp_hash */
-      0,                                        /* tp_call */
-      0,                                        /* tp_str */
-      PyObject_GenericGetAttr,                  /* tp_getattro */
-      0,                                        /* tp_setattro */
-      0,                                        /* tp_as_buffer */
-      Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
-      0,                                        /* tp_doc */
-      SwigPyStaticVar_traverse,                 /* tp_traverse */
-      0,                                        /* tp_clear */
-      0,                                        /* tp_richcompare */
-      0,                                        /* tp_weaklistoffset */
-      0,                                        /* tp_iter */
-      0,                                        /* tp_iternext */
-      0,                                        /* tp_methods */
-      0,                                        /* tp_members */
-      0,                                        /* tp_getset */
-      0,                                        /* tp_base */
-      0,                                        /* tp_dict */
-      (descrgetfunc)SwigPyStaticVar_get,        /* tp_descr_get */
-      (descrsetfunc)SwigPyStaticVar_set,        /* tp_descr_set */
-      0,                                        /* tp_dictoffset */
-      0,                                        /* tp_init */
-      0,                                        /* tp_alloc */
-      0,                                        /* tp_new */
-      0,                                        /* tp_free */
-      0,                                        /* tp_is_gc */
-      0,                                        /* tp_bases */
-      0,                                        /* tp_mro */
-      0,                                        /* tp_cache */
-      0,                                        /* tp_subclasses */
-      0,                                        /* tp_weaklist */
-#if PY_VERSION_HEX >= 0x02030000
-      0,                                        /* tp_del */
-#endif
-#if PY_VERSION_HEX >= 0x02060000
-      0,                                        /* tp_version */
-#endif
-#ifdef COUNT_ALLOCS
-      0,0,0,0                                   /* tp_alloc -> tp_next */
-#endif
-    };
-    staticvar_type = tmp;
-    type_init = 1;
-#if PY_VERSION_HEX < 0x02020000
-    staticvar_type.ob_type = &PyType_Type;
-#else
-    if (PyType_Ready(&staticvar_type) < 0)
-      return NULL;
-#endif
-  }
-  return &staticvar_type;
-}
-
-SWIGINTERN PyGetSetDescrObject *
-SwigPyStaticVar_new_getset(PyTypeObject *type, PyGetSetDef *getset) {
-
-  PyGetSetDescrObject *descr;
-  descr = (PyGetSetDescrObject *)PyType_GenericAlloc(SwigPyStaticVar_Type(), 0);
-  assert(descr);
-  Py_XINCREF(type);
-  PyDescr_TYPE(descr) = type;
-  PyDescr_NAME(descr) = PyString_InternFromString(getset->name);
-  descr->d_getset = getset;
-  if (PyDescr_NAME(descr) == NULL) {
-    Py_DECREF(descr);
-    descr = NULL;
-  }
-  return descr;
-}
-
-SWIGINTERN void
-SwigPyBuiltin_InitBases (PyTypeObject *type, PyTypeObject **bases) {
-  int base_count = 0;
-  PyTypeObject **b;
-  PyObject *tuple;
-  int i;
-
-  if (!bases[0]) {
-    bases[0] = SwigPyObject_type();
-    bases[1] = NULL;
-  }
-  type->tp_base = bases[0];
-  Py_INCREF((PyObject *)bases[0]);
-  for (b = bases; *b != NULL; ++b)
-    ++base_count;
-  tuple = PyTuple_New(base_count);
-  for (i = 0; i < base_count; ++i) {
-    PyTuple_SET_ITEM(tuple, i, (PyObject *)bases[i]);
-    Py_INCREF((PyObject *)bases[i]);
-  }
-  type->tp_bases = tuple;
-}
-
-SWIGINTERN PyObject *
-SwigPyBuiltin_ThisClosure (PyObject *self, void *SWIGUNUSEDPARM(closure)) {
-  PyObject *result;
-  result = (PyObject *)SWIG_Python_GetSwigThis(self);
-  Py_XINCREF(result);
-  return result;
-}
-
-SWIGINTERN void
-SwigPyBuiltin_SetMetaType (PyTypeObject *type, PyTypeObject *metatype)
-{
-#if PY_VERSION_HEX >= 0x03000000
-    type->ob_base.ob_base.ob_type = metatype;
-#else
-    type->ob_type = metatype;
-#endif
-}
-
-#ifdef __cplusplus
-}
-#endif
-
diff --git a/share/swig/2.0.11/python/carrays.i b/share/swig/2.0.11/python/carrays.i
deleted file mode 100644
index e578c80..0000000
--- a/share/swig/2.0.11/python/carrays.i
+++ /dev/null
@@ -1,53 +0,0 @@
-%define %array_class(TYPE,NAME)
-#if defined(SWIGPYTHON_BUILTIN)
-  %feature("python:slot", "sq_item", functype="ssizeargfunc") NAME::__getitem__;
-  %feature("python:slot", "sq_ass_item", functype="ssizeobjargproc") NAME::__setitem__;
-
-%inline %{
-typedef struct {
-    TYPE *el;
-} NAME;
-%}
-
-%extend NAME {
-
-  NAME(size_t nelements) {
-      NAME *arr = %new_instance(NAME);
-      arr->el = %new_array(nelements, TYPE);
-      return arr;
-  }
-
-  ~NAME() {
-      %delete_array(self->el);
-      %delete(self);
-  }
-  
-  TYPE __getitem__(size_t index) {
-      return self->el[index];
-  }
-
-  void __setitem__(size_t index, TYPE value) {
-      self->el[index] = value;
-  }
-
-  TYPE * cast() {
-      return self->el;
-  }
-
-  static NAME *frompointer(TYPE *t) {
-      return %reinterpret_cast(t, NAME *);
-  }
-};
-
-%types(NAME = TYPE);
-
-#else
-  %array_class_wrap(TYPE,NAME,__getitem__,__setitem__)
-#endif
-%enddef
-
-%include <typemaps/carrays.swg>
-
-
-
-
diff --git a/share/swig/2.0.11/python/director.swg b/share/swig/2.0.11/python/director.swg
deleted file mode 100644
index 97edc7e..0000000
--- a/share/swig/2.0.11/python/director.swg
+++ /dev/null
@@ -1,484 +0,0 @@
-/* -----------------------------------------------------------------------------
- * director.swg
- *
- * This file contains support for director classes that proxy
- * method calls from C++ to Python extensions.
- * ----------------------------------------------------------------------------- */
-
-#ifndef SWIG_DIRECTOR_PYTHON_HEADER_
-#define SWIG_DIRECTOR_PYTHON_HEADER_
-
-#ifdef __cplusplus
-
-#include <string>
-#include <iostream>
-#include <exception>
-#include <vector>
-#include <map>
-
-
-/*
-  Use -DSWIG_PYTHON_DIRECTOR_NO_VTABLE if you don't want to generate a 'virtual
-  table', and avoid multiple GetAttr calls to retrieve the python
-  methods.
-*/
-
-#ifndef SWIG_PYTHON_DIRECTOR_NO_VTABLE
-#ifndef SWIG_PYTHON_DIRECTOR_VTABLE
-#define SWIG_PYTHON_DIRECTOR_VTABLE
-#endif
-#endif
-
-
-
-/*
-  Use -DSWIG_DIRECTOR_NO_UEH if you prefer to avoid the use of the
-  Undefined Exception Handler provided by swig.
-*/
-#ifndef SWIG_DIRECTOR_NO_UEH
-#ifndef SWIG_DIRECTOR_UEH
-#define SWIG_DIRECTOR_UEH
-#endif
-#endif
-
-
-/*
-  Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
-  'Swig' namespace. This could be useful for multi-modules projects.
-*/
-#ifdef SWIG_DIRECTOR_STATIC
-/* Force anonymous (static) namespace */
-#define Swig
-#endif
-
-
-/*
-  Use -DSWIG_DIRECTOR_NORTTI if you prefer to avoid the use of the
-  native C++ RTTI and dynamic_cast<>. But be aware that directors
-  could stop working when using this option.
-*/
-#ifdef SWIG_DIRECTOR_NORTTI
-/* 
-   When we don't use the native C++ RTTI, we implement a minimal one
-   only for Directors.
-*/
-# ifndef SWIG_DIRECTOR_RTDIR
-# define SWIG_DIRECTOR_RTDIR
-#include <map>
-
-namespace Swig {
-  class Director;
-  SWIGINTERN std::map<void*,Director*>& get_rtdir_map() {
-    static std::map<void*,Director*> rtdir_map;
-    return rtdir_map;
-  }
-
-  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *rtdir) {
-    get_rtdir_map()[vptr] = rtdir;
-  }
-
-  SWIGINTERNINLINE Director *get_rtdir(void *vptr) {
-    std::map<void*,Director*>::const_iterator pos = get_rtdir_map().find(vptr);
-    Director *rtdir = (pos != get_rtdir_map().end()) ? pos->second : 0;
-    return rtdir;
-  }
-}
-# endif /* SWIG_DIRECTOR_RTDIR */
-
-# define SWIG_DIRECTOR_CAST(ARG) Swig::get_rtdir(static_cast<void*>(ARG))
-# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) Swig::set_rtdir(static_cast<void*>(ARG1), ARG2)
-
-#else
-
-# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG)
-# define SWIG_DIRECTOR_RGTR(ARG1, ARG2)
-
-#endif /* SWIG_DIRECTOR_NORTTI */
-
-extern "C" {
-  struct swig_type_info;
-}
-
-namespace Swig {  
-
-  /* memory handler */
-  struct GCItem 
-  {
-    virtual ~GCItem() {}
-
-    virtual int get_own() const
-    {
-      return 0;
-    }
-  };
-
-  struct GCItem_var
-  {
-    GCItem_var(GCItem *item = 0) : _item(item)
-    {
-    }
-
-    GCItem_var& operator=(GCItem *item)
-    {
-      GCItem *tmp = _item;
-      _item = item;
-      delete tmp;
-      return *this;
-    }
-
-    ~GCItem_var() 
-    {
-      delete _item;
-    }
-    
-    GCItem * operator->() const
-    {
-      return _item;
-    }
-    
-  private:
-    GCItem *_item;
-  };
-  
-  struct GCItem_Object : GCItem
-  {
-    GCItem_Object(int own) : _own(own)
-    {
-    }
-    
-    virtual ~GCItem_Object() 
-    {
-    }
-
-    int get_own() const
-    {
-      return _own;
-    }
-    
-  private:
-    int _own;
-  };
-
-  template <typename Type>
-  struct GCItem_T : GCItem
-  {
-    GCItem_T(Type *ptr) : _ptr(ptr)
-    {
-    }
-    
-    virtual ~GCItem_T() 
-    {
-      delete _ptr;
-    }
-    
-  private:
-    Type *_ptr;
-  };
-
-  template <typename Type>
-  struct GCArray_T : GCItem
-  {
-    GCArray_T(Type *ptr) : _ptr(ptr)
-    {
-    }
-    
-    virtual ~GCArray_T() 
-    {
-      delete[] _ptr;
-    }
-    
-  private:
-    Type *_ptr;
-  };
-
-  /* base class for director exceptions */
-  class DirectorException {
-  protected:
-    std::string swig_msg;
-  public:
-    DirectorException(PyObject *error, const char* hdr ="", const char* msg ="") 
-      : swig_msg(hdr)
-    {
-      SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
-      if (strlen(msg)) {
-        swig_msg += " ";
-        swig_msg += msg;
-      }
-      if (!PyErr_Occurred()) {
-        PyErr_SetString(error, getMessage());
-      }
-      SWIG_PYTHON_THREAD_END_BLOCK; 
-    }
-
-    const char *getMessage() const
-    { 
-      return swig_msg.c_str(); 
-    }
-
-    static void raise(PyObject *error, const char *msg) 
-    {
-      throw DirectorException(error, msg);
-    }
-
-    static void raise(const char *msg) 
-    {
-      raise(PyExc_RuntimeError, msg);
-    }
-  };
-
-  /* unknown exception handler  */
-  class UnknownExceptionHandler 
-  {
-#ifdef SWIG_DIRECTOR_UEH
-    static void handler()  {
-      try {
-        throw;
-      } catch (DirectorException& e) {
-        std::cerr << "SWIG Director exception caught:" << std::endl
-                  << e.getMessage() << std::endl;
-      } catch (std::exception& e) {
-        std::cerr << "std::exception caught: "<< e.what() << std::endl;
-      } catch (...) {
-        std::cerr << "Unknown exception caught." << std::endl;
-      }
-      
-      std::cerr << std::endl
-                << "Python interpreter traceback:" << std::endl;
-      PyErr_Print();
-      std::cerr << std::endl;
-      
-      std::cerr << "This exception was caught by the SWIG unexpected exception handler." << std::endl
-                << "Try using %feature(\"director:except\") to avoid reaching this point." << std::endl
-                << std::endl
-                << "Exception is being re-thrown, program will likely abort/terminate." << std::endl;
-      throw;
-    }
-
-  public:
-    
-    std::unexpected_handler old;
-    UnknownExceptionHandler(std::unexpected_handler nh = handler)
-    {
-      old = std::set_unexpected(nh);
-    }
-
-    ~UnknownExceptionHandler()
-    {
-      std::set_unexpected(old);
-    }
-#endif
-  };
-
-  /* type mismatch in the return value from a python method call */
-  class DirectorTypeMismatchException : public Swig::DirectorException {
-  public:
-    DirectorTypeMismatchException(PyObject *error, const char* msg="") 
-      : Swig::DirectorException(error, "SWIG director type mismatch", msg)
-    {
-    }
-
-    DirectorTypeMismatchException(const char* msg="") 
-      : Swig::DirectorException(PyExc_TypeError, "SWIG director type mismatch", msg)
-    {
-    }
-
-    static void raise(PyObject *error, const char *msg)
-    {
-      throw DirectorTypeMismatchException(error, msg);
-    }
-
-    static void raise(const char *msg)
-    {
-      throw DirectorTypeMismatchException(msg);
-    }
-  };
-
-  /* any python exception that occurs during a director method call */
-  class DirectorMethodException : public Swig::DirectorException {
-  public:
-    DirectorMethodException(const char* msg = "") 
-      : DirectorException(PyExc_RuntimeError, "SWIG director method error.", msg)
-    {
-    }    
-
-    static void raise(const char *msg)
-    {
-      throw DirectorMethodException(msg);
-    }
-  };
-
-  /* attempt to call a pure virtual method via a director method */
-  class DirectorPureVirtualException : public Swig::DirectorException
-  {
-  public:
-    DirectorPureVirtualException(const char* msg = "") 
-      : DirectorException(PyExc_RuntimeError, "SWIG director pure virtual method called", msg)
-    { 
-    }
-
-    static void raise(const char *msg) 
-    {
-      throw DirectorPureVirtualException(msg);
-    }
-  };
-
-
-#if defined(SWIG_PYTHON_THREADS)
-/*  __THREAD__ is the old macro to activate some thread support */
-# if !defined(__THREAD__)
-#   define __THREAD__ 1
-# endif
-#endif
-
-#ifdef __THREAD__
-# include "pythread.h"
-  class Guard
-  {
-    PyThread_type_lock & mutex_;
-    
-  public:
-    Guard(PyThread_type_lock & mutex) : mutex_(mutex)
-    {
-      PyThread_acquire_lock(mutex_, WAIT_LOCK);
-    }
-    
-    ~Guard()
-    {
-      PyThread_release_lock(mutex_);
-    }
-  };
-# define SWIG_GUARD(mutex) Guard _guard(mutex)
-#else
-# define SWIG_GUARD(mutex) 
-#endif
-
-  /* director base class */
-  class Director {
-  private:
-    /* pointer to the wrapped python object */
-    PyObject* swig_self;
-    /* flag indicating whether the object is owned by python or c++ */
-    mutable bool swig_disown_flag;
-
-    /* decrement the reference count of the wrapped python object */
-    void swig_decref() const { 
-      if (swig_disown_flag) {
-        SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
-        Py_DECREF(swig_self); 
-        SWIG_PYTHON_THREAD_END_BLOCK; 
-      }
-    }
-
-  public:
-    /* wrap a python object, optionally taking ownership */
-    Director(PyObject* self) : swig_self(self), swig_disown_flag(false) {
-      swig_incref();
-    }
-
-
-    /* discard our reference at destruction */
-    virtual ~Director() {
-      swig_decref(); 
-    }
-
-
-    /* return a pointer to the wrapped python object */
-    PyObject *swig_get_self() const { 
-      return swig_self; 
-    }
-
-    /* acquire ownership of the wrapped python object (the sense of "disown"
-     * is from python) */
-    void swig_disown() const { 
-      if (!swig_disown_flag) { 
-        swig_disown_flag=true;
-        swig_incref(); 
-      } 
-    }
-
-    /* increase the reference count of the wrapped python object */
-    void swig_incref() const { 
-      if (swig_disown_flag) {
-        Py_INCREF(swig_self); 
-      }
-    }
-
-    /* methods to implement pseudo protected director members */
-    virtual bool swig_get_inner(const char* /* swig_protected_method_name */) const {
-      return true;
-    }
-    
-    virtual void swig_set_inner(const char* /* swig_protected_method_name */, bool /* swig_val */) const {
-    }
-
-  /* ownership management */
-  private:
-    typedef std::map<void*, GCItem_var> swig_ownership_map;
-    mutable swig_ownership_map swig_owner;
-#ifdef __THREAD__
-    static PyThread_type_lock swig_mutex_own;
-#endif
-
-  public:
-    template <typename Type>
-    void swig_acquire_ownership_array(Type *vptr)  const
-    {
-      if (vptr) {
-        SWIG_GUARD(swig_mutex_own);
-        swig_owner[vptr] = new GCArray_T<Type>(vptr);
-      }
-    }
-    
-    template <typename Type>
-    void swig_acquire_ownership(Type *vptr)  const
-    {
-      if (vptr) {
-        SWIG_GUARD(swig_mutex_own);
-        swig_owner[vptr] = new GCItem_T<Type>(vptr);
-      }
-    }
-
-    void swig_acquire_ownership_obj(void *vptr, int own) const
-    {
-      if (vptr && own) {
-        SWIG_GUARD(swig_mutex_own);
-        swig_owner[vptr] = new GCItem_Object(own);
-      }
-    }
-    
-    int swig_release_ownership(void *vptr) const
-    {
-      int own = 0;
-      if (vptr) {
-        SWIG_GUARD(swig_mutex_own);
-        swig_ownership_map::iterator iter = swig_owner.find(vptr);
-        if (iter != swig_owner.end()) {
-          own = iter->second->get_own();
-          swig_owner.erase(iter);
-        }
-      }
-      return own;
-    }
-
-    template <typename Type>
-    static PyObject* swig_pyobj_disown(PyObject *pyobj, PyObject *SWIGUNUSEDPARM(args))
-    {
-      SwigPyObject *sobj = (SwigPyObject *)pyobj;
-      sobj->own = 0;
-      Director *d = SWIG_DIRECTOR_CAST(reinterpret_cast<Type *>(sobj->ptr));
-      if (d)
-        d->swig_disown();
-      return PyWeakref_NewProxy(pyobj, NULL);
-    }
-
-  };
-
-#ifdef __THREAD__
-  PyThread_type_lock Director::swig_mutex_own = PyThread_allocate_lock();
-#endif
-}
-
-#endif /* __cplusplus */
-
-
-#endif
diff --git a/share/swig/2.0.11/python/embed.i b/share/swig/2.0.11/python/embed.i
deleted file mode 100644
index c29e8fd..0000000
--- a/share/swig/2.0.11/python/embed.i
+++ /dev/null
@@ -1,115 +0,0 @@
-//
-// embed.i
-// SWIG file embedding the Python interpreter in something else.
-// This file is based on Python-1.5.  It will not work with
-// earlier versions.
-//
-// This file makes it possible to extend Python and all of its
-// built-in functions without having to hack its setup script.
-//
-
-
-#ifdef AUTODOC
-%subsection "embed.i"
-%text %{
-This module provides support for building a new version of the
-Python executable.  This will be necessary on systems that do
-not support shared libraries and may be necessary with C++
-extensions.  This file contains everything you need to build
-a new version of Python from include files and libraries normally
-installed with the Python language.
-
-This module will automatically grab all of the Python modules
-present in your current Python executable (including any special
-purpose modules you have enabled such as Tkinter).   Thus, you
-may need to provide additional link libraries when compiling.
-
-This library file only works with Python 1.5.  A version 
-compatible with Python 1.4 is available as embed14.i and
-a Python1.3 version is available as embed13.i.    As far as
-I know, this module is C++ safe.
-%}
-#else
-%echo "embed.i : Using Python 1.5"
-#endif
-
-%wrapper %{
-
-#include <Python.h>
-
-#ifdef __cplusplus
-extern "C"
-#endif
-void SWIG_init();  /* Forward reference */
-
-#define _PyImport_Inittab swig_inittab
-
-/* Grab Python's inittab[] structure */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include <config.c>
-
-#undef _PyImport_Inittab 
-
-/* Now define our own version of it.
-   Hopefully someone does not have more than 1000 built-in modules */
-
-struct _inittab SWIG_Import_Inittab[1000];       
-
-static int  swig_num_modules = 0;
-
-/* Function for adding modules to Python */
-
-static void swig_add_module(char *name, void (*initfunc)()) {
-	SWIG_Import_Inittab[swig_num_modules].name = name;
-	SWIG_Import_Inittab[swig_num_modules].initfunc = initfunc;
-	swig_num_modules++;
-	SWIG_Import_Inittab[swig_num_modules].name = (char *) 0;
-	SWIG_Import_Inittab[swig_num_modules].initfunc = 0;
-}				
-
-/* Function to add all of Python's build in modules to our interpreter */
-
-static void swig_add_builtin() {
-	int i = 0;
-	while (swig_inittab[i].name) {
-		swig_add_module(swig_inittab[i].name, swig_inittab[i].initfunc);
-  	        i++;
- 	}
-#ifdef SWIGMODINIT
-	SWIGMODINIT	
-#endif
-	/* Add SWIG builtin function */
-	swig_add_module(SWIG_name, SWIG_init);
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern int Py_Main(int, char **);
-
-#ifdef __cplusplus
-}
-#endif
-
-extern struct _inittab *PyImport_Inittab;
-
-int
-main(int argc, char **argv) {
-	swig_add_builtin();
-	PyImport_Inittab = SWIG_Import_Inittab;
-	return Py_Main(argc,argv);
-}
-
-%}
-
-
-  
-
diff --git a/share/swig/2.0.11/python/embed15.i b/share/swig/2.0.11/python/embed15.i
deleted file mode 100644
index 3c419b9..0000000
--- a/share/swig/2.0.11/python/embed15.i
+++ /dev/null
@@ -1,115 +0,0 @@
-/* -----------------------------------------------------------------------------
- * embed15.i
- *
- * SWIG file embedding the Python interpreter in something else.
- * This file is based on Python-1.5.  It will not work with
- * earlier versions.
- *
- * This file makes it possible to extend Python and all of its
- * built-in functions without having to hack its setup script.
- * ----------------------------------------------------------------------------- */
-
-#ifdef AUTODOC
-%subsection "embed.i"
-%text %{
-This module provides support for building a new version of the
-Python executable.  This will be necessary on systems that do
-not support shared libraries and may be necessary with C++
-extensions.  This file contains everything you need to build
-a new version of Python from include files and libraries normally
-installed with the Python language.
-
-This module will automatically grab all of the Python modules
-present in your current Python executable (including any special
-purpose modules you have enabled such as Tkinter).   Thus, you
-may need to provide additional link libraries when compiling.
-
-This library file only works with Python 1.5.  A version 
-compatible with Python 1.4 is available as embed14.i and
-a Python1.3 version is available as embed13.i.    As far as
-I know, this module is C++ safe.
-%}
-#else
-%echo "embed.i : Using Python 1.5"
-#endif
-
-%wrapper %{
-
-#include <Python.h>
-
-#ifdef __cplusplus
-extern "C"
-#endif
-void SWIG_init();  /* Forward reference */
-
-#define _PyImport_Inittab swig_inittab
-
-/* Grab Python's inittab[] structure */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include <config.c>
-
-#undef _PyImport_Inittab 
-
-/* Now define our own version of it.
-   Hopefully someone does not have more than 1000 built-in modules */
-
-struct _inittab SWIG_Import_Inittab[1000];       
-
-static int  swig_num_modules = 0;
-
-/* Function for adding modules to Python */
-
-static void swig_add_module(char *name, void (*initfunc)()) {
-	SWIG_Import_Inittab[swig_num_modules].name = name;
-	SWIG_Import_Inittab[swig_num_modules].initfunc = initfunc;
-	swig_num_modules++;
-	SWIG_Import_Inittab[swig_num_modules].name = (char *) 0;
-	SWIG_Import_Inittab[swig_num_modules].initfunc = 0;
-}				
-
-/* Function to add all of Python's build in modules to our interpreter */
-
-static void swig_add_builtin() {
-	int i = 0;
-	while (swig_inittab[i].name) {
-		swig_add_module(swig_inittab[i].name, swig_inittab[i].initfunc);
-  	        i++;
- 	}
-#ifdef SWIGMODINIT
-	SWIGMODINIT	
-#endif
-	/* Add SWIG builtin function */
-	swig_add_module(SWIG_name, SWIG_init);
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern int Py_Main(int, char **);
-
-#ifdef __cplusplus
-}
-#endif
-
-extern struct _inittab *PyImport_Inittab;
-
-int
-main(int argc, char **argv) {
-	swig_add_builtin();
-	PyImport_Inittab = SWIG_Import_Inittab;
-	return Py_Main(argc,argv);
-}
-
-%}
-
-
-  
-
diff --git a/share/swig/2.0.11/python/exception.i b/share/swig/2.0.11/python/exception.i
deleted file mode 100644
index bb0b15c..0000000
--- a/share/swig/2.0.11/python/exception.i
+++ /dev/null
@@ -1,6 +0,0 @@
-%include <typemaps/exception.swg>
-
-
-%insert("runtime") {
-  %define_as(SWIG_exception(code, msg), %block(%error(code, msg); SWIG_fail; ))
-}
diff --git a/share/swig/2.0.11/python/pyabc.i b/share/swig/2.0.11/python/pyabc.i
deleted file mode 100644
index 3da06b5..0000000
--- a/share/swig/2.0.11/python/pyabc.i
+++ /dev/null
@@ -1,10 +0,0 @@
-%define %pythonabc(Type, Abc)
-  %feature("python:abc", #Abc) Type;
-%enddef
-%pythoncode {import collections};
-%pythonabc(std::vector, collections.MutableSequence);
-%pythonabc(std::list, collections.MutableSequence);
-%pythonabc(std::map, collections.MutableMapping);
-%pythonabc(std::multimap, collections.MutableMapping);
-%pythonabc(std::set, collections.MutableSet);
-%pythonabc(std::multiset, collections.MutableSet);
diff --git a/share/swig/2.0.11/python/pyclasses.swg b/share/swig/2.0.11/python/pyclasses.swg
deleted file mode 100644
index b73ebdb..0000000
--- a/share/swig/2.0.11/python/pyclasses.swg
+++ /dev/null
@@ -1,149 +0,0 @@
-#ifdef __cplusplus
-
-/*
-  SwigPtr_PyObject is used as a replacement of PyObject *, where
-  the INCREF/DECREF are applied as needed.
-
-  You can use SwigPtr_PyObject in a container, such as
-  
-     std::vector<SwigPtr_PyObject>;
-
-  or as a member variable:
-  
-     struct A {
-       SwigPtr_PyObject obj;
-       A(PyObject *o) : _obj(o) {
-       }
-     };
-
-   or as a input/output value 
-
-     SwigPtr_PyObject func(SwigPtr_PyObject obj) {     
-       SwigPtr_PyObject out = PyString_FromFormat("hello %s", PyObject_AsString(obj));
-       Py_DECREF(out);
-       return out;
-     }
-
-   just remember to pair the object creation with the proper DECREF,
-   the same as with plain PyObject *ptr, since SwigPtr_PyObject always add
-   one reference at construction.
-
-   SwigPtr_PyObject is 'visible' at the wrapped side, so you can do:
-
-
-      %template(pyvector) std::vector<swig::SwigPtr_PyObject>;
-
-   and all the proper typemaps will be used.
-   
-*/
-
-namespace swig {
-  %ignore SwigPtr_PyObject;
-  struct SwigPtr_PyObject {};
-  %apply PyObject * {SwigPtr_PyObject};
-  %apply PyObject * const& {SwigPtr_PyObject const&};
-
-  %typemap(typecheck,precedence=SWIG_TYPECHECK_SWIGOBJECT,noblock=1) SwigPtr_PyObject const& "$1 = ($input != 0);";
-
-
-  /* For output */
-  %typemap(out,noblock=1)  SwigPtr_PyObject {
-    $result = (PyObject *)$1;
-    Py_INCREF($result);
-  }
-  
-  %typemap(out,noblock=1)  SwigPtr_PyObject const & {
-    $result = (PyObject *)*$1;
-    Py_INCREF($result);
-  }
-  
-}
-
-%{
-namespace swig {
-  class SwigPtr_PyObject {
-  protected:
-    PyObject *_obj;
-
-  public:
-    SwigPtr_PyObject() :_obj(0)
-    {
-    }
-
-    SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
-    {
-      Py_XINCREF(_obj);      
-    }
-    
-    SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
-    {
-      if (initial_ref) {
-        Py_XINCREF(_obj);
-      }
-    }
-    
-    SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) 
-    {
-      Py_XINCREF(item._obj);
-      Py_XDECREF(_obj);
-      _obj = item._obj;
-      return *this;      
-    }
-    
-    ~SwigPtr_PyObject() 
-    {
-      Py_XDECREF(_obj);
-    }
-    
-    operator PyObject *() const
-    {
-      return _obj;
-    }
-
-    PyObject *operator->() const
-    {
-      return _obj;
-    }
-  };
-}
-%}
-
-/*
-  SwigVar_PyObject is used to manage 'in the scope' PyObject * variables,
-  as in
-
-  int func () {
-    SwigVar_PyObject obj = PyString_FromString("hello");
-  }
-
-  ie, 'obj' is created and destructed in the same scope from
-  a python object that carries at least one reference value.
-  
-  SwigVar_PyObject just take care of applying the proper Py_DECREF.
-
-  Hence, this class is purely internal and not visible at the wrapped side.
- */
-namespace swig {
-  %ignore SwigVar_PyObject;
-  struct SwigVar_PyObject {};
-  %apply PyObject * {SwigVar_PyObject};
-  %apply PyObject * const& {SwigVar_PyObject const&};
-}
-
-%{
-namespace swig {
-  struct SwigVar_PyObject : SwigPtr_PyObject {
-    SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
-    
-    SwigVar_PyObject & operator = (PyObject* obj)
-    {
-      Py_XDECREF(_obj);
-      _obj = obj;
-      return *this;      
-    }
-  };
-}
-%}
-
-
-#endif
diff --git a/share/swig/2.0.11/python/pycomplex.swg b/share/swig/2.0.11/python/pycomplex.swg
deleted file mode 100644
index 74be5b9..0000000
--- a/share/swig/2.0.11/python/pycomplex.swg
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
-  Defines the As/From converters for double/float complex, you need to
-  provide complex Type, the Name you want to use in the converters,
-  the complex Constructor method, and the Real and Imag complex
-  accessor methods.
-
-  See the std_complex.i and ccomplex.i for concret examples.
-*/
-
-/* the common from converter */
-%define %swig_fromcplx_conv(Type, Real, Imag)
-%fragment(SWIG_From_frag(Type),"header")
-{
-SWIGINTERNINLINE PyObject*
-SWIG_From(Type)(%ifcplusplus(const Type&, Type) c)
-{
-  return PyComplex_FromDoubles(Real(c), Imag(c));
-}
-}
-%enddef
-
-/* the double case */
-%define %swig_cplxdbl_conv(Type, Constructor, Real, Imag)
-%fragment(SWIG_AsVal_frag(Type),"header",
-	  fragment=SWIG_AsVal_frag(double))
-{
-SWIGINTERN int
-SWIG_AsVal(Type) (PyObject *o, Type* val)
-{
-  if (PyComplex_Check(o)) {
-    if (val) *val = Constructor(PyComplex_RealAsDouble(o), PyComplex_ImagAsDouble(o));
-    return SWIG_OK;
-  } else {
-    double d;    
-    int res = SWIG_AddCast(SWIG_AsVal(double)(o, &d));
-    if (SWIG_IsOK(res)) {
-      if (val) *val = Constructor(d, 0.0);
-      return res;
-    }
-  }
-  return SWIG_TypeError;
-}
-}
-%swig_fromcplx_conv(Type, Real, Imag);
-%enddef
-
-/* the float case */
-%define %swig_cplxflt_conv(Type, Constructor, Real, Imag)
-%fragment(SWIG_AsVal_frag(Type),"header",
-          fragment=SWIG_AsVal_frag(float)) {
-SWIGINTERN int
-SWIG_AsVal(Type)(PyObject *o, Type *val)
-{
-  if (PyComplex_Check(o)) {
-    double re = PyComplex_RealAsDouble(o);
-    double im = PyComplex_ImagAsDouble(o);
-    if ((-FLT_MAX <= re && re <= FLT_MAX) && (-FLT_MAX <= im && im <= FLT_MAX)) {
-      if (val) *val = Constructor(%numeric_cast(re, float),
-				  %numeric_cast(im, float));
-      return SWIG_OK;
-    } else {
-      return SWIG_OverflowError;
-    }    
-  } else {
-    float re;
-    int res = SWIG_AddCast(SWIG_AsVal(float)(o, &re));
-    if (SWIG_IsOK(res)) {
-      if (val) *val = Constructor(re, 0.0);
-      return res;
-    }
-  }
-  return SWIG_TypeError;
-}
-}
-
-%swig_fromcplx_conv(Type, Real, Imag);
-%enddef
-
-#define %swig_cplxflt_convn(Type, Constructor, Real, Imag) \
-%swig_cplxflt_conv(Type, Constructor, Real, Imag)
-
-
-#define %swig_cplxdbl_convn(Type, Constructor, Real, Imag) \
-%swig_cplxdbl_conv(Type, Constructor, Real, Imag)
-
-
diff --git a/share/swig/2.0.11/python/pycontainer.swg b/share/swig/2.0.11/python/pycontainer.swg
deleted file mode 100644
index d438662..0000000
--- a/share/swig/2.0.11/python/pycontainer.swg
+++ /dev/null
@@ -1,992 +0,0 @@
-/* -----------------------------------------------------------------------------
- * pycontainer.swg
- *
- * Python sequence <-> C++ container wrapper
- *
- * This wrapper, and its iterator, allows a general use (and reuse) of
- * the mapping between C++ and Python, thanks to the C++ templates.
- *
- * Of course, it needs the C++ compiler to support templates, but
- * since we will use this wrapper with the STL containers, that should
- * be the case.
- * ----------------------------------------------------------------------------- */
-
-%{
-#include <iostream>
-
-#if PY_VERSION_HEX >= 0x03020000
-# define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
-#else
-# define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
-#endif
-%}
-
-
-#if !defined(SWIG_NO_EXPORT_ITERATOR_METHODS)
-# if !defined(SWIG_EXPORT_ITERATOR_METHODS)
-#  define SWIG_EXPORT_ITERATOR_METHODS SWIG_EXPORT_ITERATOR_METHODS
-# endif
-#endif
-
-%include <pyiterators.swg>
-
-/**** The PySequence C++ Wrap ***/
-
-%insert(header) %{
-#include <stdexcept>
-%}
-
-%include <std_except.i>
-
-%fragment(SWIG_Traits_frag(swig::SwigPtr_PyObject),"header",fragment="StdTraits") {
-namespace swig {
-  template <>  struct traits<SwigPtr_PyObject > {
-    typedef value_category category;
-    static const char* type_name() { return  "SwigPtr_PyObject"; }
-  };
-  
-  template <>  struct traits_from<SwigPtr_PyObject> {
-    typedef SwigPtr_PyObject value_type;
-    static PyObject *from(const value_type& val) {
-      PyObject *obj = static_cast<PyObject *>(val);
-      Py_XINCREF(obj);
-      return obj;
-    }
-  };
-  
-  template <> 
-  struct traits_check<SwigPtr_PyObject, value_category> {
-    static bool check(SwigPtr_PyObject) {
-      return true;
-    }
-  };
-  
-  template <>  struct traits_asval<SwigPtr_PyObject > {   
-    typedef SwigPtr_PyObject value_type;
-    static int asval(PyObject *obj, value_type *val) {
-      if (val) *val = obj;
-      return SWIG_OK;
-    }
-  };
-}
-}
-
-%fragment(SWIG_Traits_frag(swig::SwigVar_PyObject),"header",fragment="StdTraits") {
-namespace swig {
-  template <>  struct traits<SwigVar_PyObject > {
-    typedef value_category category;
-    static const char* type_name() { return  "SwigVar_PyObject"; }
-  };
-  
-  template <>  struct traits_from<SwigVar_PyObject> {
-    typedef SwigVar_PyObject value_type;
-    static PyObject *from(const value_type& val) {
-      PyObject *obj = static_cast<PyObject *>(val);
-      Py_XINCREF(obj);
-      return obj;
-    }
-  };
-  
-  template <> 
-  struct traits_check<SwigVar_PyObject, value_category> {
-    static bool check(SwigVar_PyObject) {
-      return true;
-    }
-  };
-  
-  template <>  struct traits_asval<SwigVar_PyObject > {   
-    typedef SwigVar_PyObject value_type;
-    static int asval(PyObject *obj, value_type *val) {
-      if (val) *val = obj;
-      return SWIG_OK;
-    }
-  };
-} 
-}
-
-%fragment("SwigPySequence_Base","header",fragment="<stddef.h>")
-{
-%#include <functional>
-
-namespace std {
-  template <>
-  struct less <PyObject *>: public binary_function<PyObject *, PyObject *, bool>
-  {
-    bool
-    operator()(PyObject * v, PyObject *w) const
-    { 
-      bool res;
-      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
-      res = PyObject_RichCompareBool(v, w, Py_LT) ? true : false;
-      /* This may fall into a case of inconsistent
-               eg. ObjA > ObjX > ObjB
-               but ObjA < ObjB
-      */
-      if( PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError) )
-      {
-        /* Objects can't be compared, this mostly occurred in Python 3.0 */
-        /* Compare their ptr directly for a workaround */
-        res = (v < w);
-        PyErr_Clear();
-      }
-      SWIG_PYTHON_THREAD_END_BLOCK;
-      return res;
-    }
-  };
-
-  template <>
-  struct less <swig::SwigPtr_PyObject>: public binary_function<swig::SwigPtr_PyObject, swig::SwigPtr_PyObject, bool>
-  {
-    bool
-    operator()(const swig::SwigPtr_PyObject& v, const swig::SwigPtr_PyObject& w) const
-    {
-      return std::less<PyObject *>()(v, w);
-    }
-  };
-
-  template <>
-  struct less <swig::SwigVar_PyObject>: public binary_function<swig::SwigVar_PyObject, swig::SwigVar_PyObject, bool>
-  {
-    bool
-    operator()(const swig::SwigVar_PyObject& v, const swig::SwigVar_PyObject& w) const
-    {
-      return std::less<PyObject *>()(v, w);
-    }
-  };
-
-}
-
-namespace swig {
-  template <> struct traits<PyObject *> {
-    typedef value_category category;
-    static const char* type_name() { return "PyObject *"; }
-  };  
-
-  template <>  struct traits_asval<PyObject * > {   
-    typedef PyObject * value_type;
-    static int asval(PyObject *obj, value_type *val) {
-      if (val) *val = obj;
-      return SWIG_OK;
-    }
-  };
-
-  template <> 
-  struct traits_check<PyObject *, value_category> {
-    static bool check(PyObject *) {
-      return true;
-    }
-  };
-
-  template <>  struct traits_from<PyObject *> {
-    typedef PyObject * value_type;
-    static PyObject *from(const value_type& val) {
-      Py_XINCREF(val);
-      return val;
-    }
-  };
-  
-}
-
-namespace swig {
-  template <class Difference>
-  inline size_t
-  check_index(Difference i, size_t size, bool insert = false) {
-    if ( i < 0 ) {
-      if ((size_t) (-i) <= size)
-	return (size_t) (i + size);
-    } else if ( (size_t) i < size ) {
-      return (size_t) i;
-    } else if (insert && ((size_t) i == size)) {
-      return size;
-    }
-    throw std::out_of_range("index out of range");
-  }
-
-  template <class Difference>
-  void
-  slice_adjust(Difference i, Difference j, Py_ssize_t step, size_t size, Difference &ii, Difference &jj, bool insert = false) {
-    if (step == 0) {
-      throw std::invalid_argument("slice step cannot be zero");
-    } else if (step > 0) {
-      // Required range: 0 <= i < size, 0 <= j < size
-      if (i < 0) {
-        ii = 0;
-      } else if (i < (Difference)size) {
-        ii = i;
-      } else if (insert && (i >= (Difference)size)) {
-        ii = (Difference)size;
-      }
-      if ( j < 0 ) {
-        jj = 0;
-      } else {
-        jj = (j < (Difference)size) ? j : (Difference)size;
-      }
-    } else {
-      // Required range: -1 <= i < size-1, -1 <= j < size-1
-      if (i < -1) {
-        ii = -1;
-      } else if (i < (Difference) size) {
-        ii = i;
-      } else if (i >= (Difference)(size-1)) {
-        ii = (Difference)(size-1);
-      }
-      if (j < -1) {
-        jj = -1;
-      } else {
-        jj = (j < (Difference)size ) ? j : (Difference)(size-1);
-      }
-    }
-  }
-
-  template <class Sequence, class Difference>
-  inline typename Sequence::iterator
-  getpos(Sequence* self, Difference i)  {
-    typename Sequence::iterator pos = self->begin();
-    std::advance(pos, check_index(i,self->size()));
-    return pos;
-  }
-
-  template <class Sequence, class Difference>
-  inline typename Sequence::const_iterator
-  cgetpos(const Sequence* self, Difference i)  {
-    typename Sequence::const_iterator pos = self->begin();
-    std::advance(pos, check_index(i,self->size()));
-    return pos;
-  }
-
-  template <class Sequence, class Difference>
-  inline Sequence*
-  getslice(const Sequence* self, Difference i, Difference j, Py_ssize_t step) {
-    typename Sequence::size_type size = self->size();
-    Difference ii = 0;
-    Difference jj = 0;
-    swig::slice_adjust(i, j, step, size, ii, jj);
-
-    if (step > 0) {
-      typename Sequence::const_iterator sb = self->begin();
-      typename Sequence::const_iterator se = self->begin();
-      std::advance(sb,ii);
-      std::advance(se,jj);
-      if (step == 1) {
-        return new Sequence(sb, se);
-      } else {
-        Sequence *sequence = new Sequence();
-        typename Sequence::const_iterator it = sb;
-        while (it!=se) {
-          sequence->push_back(*it);
-          for (Py_ssize_t c=0; c<step && it!=se; ++c)
-            it++;
-        }
-        return sequence;
-      } 
-    } else {
-      Sequence *sequence = new Sequence();
-      if (ii > jj) {
-        typename Sequence::const_reverse_iterator sb = self->rbegin();
-        typename Sequence::const_reverse_iterator se = self->rbegin();
-        std::advance(sb,size-ii-1);
-        std::advance(se,size-jj-1);
-        typename Sequence::const_reverse_iterator it = sb;
-        while (it!=se) {
-          sequence->push_back(*it);
-          for (Py_ssize_t c=0; c<-step && it!=se; ++c)
-            it++;
-        }
-      }
-      return sequence;
-    }
-  }
-
-  template <class Sequence, class Difference, class InputSeq>
-  inline void
-  setslice(Sequence* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) {
-    typename Sequence::size_type size = self->size();
-    Difference ii = 0;
-    Difference jj = 0;
-    swig::slice_adjust(i, j, step, size, ii, jj, true);
-    if (step > 0) {
-      if (jj < ii)
-        jj = ii;
-      if (step == 1) {
-        size_t ssize = jj - ii;
-        if (ssize <= is.size()) {
-          // expanding/staying the same size
-          typename Sequence::iterator sb = self->begin();
-          typename InputSeq::const_iterator isit = is.begin();
-          std::advance(sb,ii);
-          std::advance(isit, jj - ii);
-          self->insert(std::copy(is.begin(), isit, sb), isit, is.end());
-        } else {
-          // shrinking
-          typename Sequence::iterator sb = self->begin();
-          typename Sequence::iterator se = self->begin();
-          std::advance(sb,ii);
-          std::advance(se,jj);
-          self->erase(sb,se);
-          sb = self->begin();
-          std::advance(sb,ii);
-          self->insert(sb, is.begin(), is.end());
-        }
-      } else {
-        size_t replacecount = (jj - ii + step - 1) / step;
-        if (is.size() != replacecount) {
-          char msg[1024];
-          sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
-          throw std::invalid_argument(msg);
-        }
-        typename Sequence::const_iterator isit = is.begin();
-        typename Sequence::iterator it = self->begin();
-        std::advance(it,ii);
-        for (size_t rc=0; rc<replacecount; ++rc) {
-          *it++ = *isit++;
-          for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
-            it++;
-        }
-      }
-    } else {
-      if (jj > ii)
-        jj = ii;
-      size_t replacecount = (ii - jj - step - 1) / -step;
-      if (is.size() != replacecount) {
-        char msg[1024];
-        sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
-        throw std::invalid_argument(msg);
-      }
-      typename Sequence::const_iterator isit = is.begin();
-      typename Sequence::reverse_iterator it = self->rbegin();
-      std::advance(it,size-ii-1);
-      for (size_t rc=0; rc<replacecount; ++rc) {
-        *it++ = *isit++;
-        for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
-          it++;
-      }
-    }
-  }
-
-  template <class Sequence, class Difference>
-  inline void
-  delslice(Sequence* self, Difference i, Difference j, Py_ssize_t step) {
-    typename Sequence::size_type size = self->size();
-    Difference ii = 0;
-    Difference jj = 0;
-    swig::slice_adjust(i, j, step, size, ii, jj, true);
-    if (step > 0) {
-      if (jj > ii) {
-        typename Sequence::iterator sb = self->begin();
-        std::advance(sb,ii);
-        if (step == 1) {
-          typename Sequence::iterator se = self->begin();
-          std::advance(se,jj);
-          self->erase(sb,se);
-        } else {
-          typename Sequence::iterator it = sb;
-          size_t delcount = (jj - ii + step - 1) / step;
-          while (delcount) {
-            it = self->erase(it);
-            for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
-              it++;
-            delcount--;
-          }
-        }
-      }
-    } else {
-      if (ii > jj) {
-        typename Sequence::reverse_iterator sb = self->rbegin();
-        std::advance(sb,size-ii-1);
-        typename Sequence::reverse_iterator it = sb;
-        size_t delcount = (ii - jj - step - 1) / -step;
-        while (delcount) {
-          it = typename Sequence::reverse_iterator(self->erase((++it).base()));
-          for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
-            it++;
-          delcount--;
-        }
-      }
-    }
-  }
-}
-}
-
-%fragment("SwigPySequence_Cont","header",
-	  fragment="StdTraits",
-	  fragment="SwigPySequence_Base",
-	  fragment="SwigPyIterator_T")
-{
-namespace swig
-{
-  template <class T>
-  struct SwigPySequence_Ref
-  {
-    SwigPySequence_Ref(PyObject* seq, int index)
-      : _seq(seq), _index(index)
-    {
-    }
-    
-    operator T () const
-    {
-      swig::SwigVar_PyObject item = PySequence_GetItem(_seq, _index);
-      try {
-	return swig::as<T>(item, true);
-      } catch (std::exception& e) {
-	char msg[1024];
-	sprintf(msg, "in sequence element %d ", _index);
-	if (!PyErr_Occurred()) {
-	  ::%type_error(swig::type_name<T>());
-	}
-	SWIG_Python_AddErrorMsg(msg);
-	SWIG_Python_AddErrorMsg(e.what());
-	throw;
-      }
-    }
-
-    SwigPySequence_Ref& operator=(const T& v)
-    {
-      PySequence_SetItem(_seq, _index, swig::from<T>(v));
-      return *this;
-    }
-
-  private:
-    PyObject* _seq;
-    int _index;
-  };
-
-  template <class T>
-  struct SwigPySequence_ArrowProxy
-  {
-    SwigPySequence_ArrowProxy(const T& x): m_value(x) {}
-    const T* operator->() const { return &m_value; }
-    operator const T*() const { return &m_value; }
-    T m_value;
-  };
-
-  template <class T, class Reference >
-  struct SwigPySequence_InputIterator
-  {
-    typedef SwigPySequence_InputIterator<T, Reference > self;
-
-    typedef std::random_access_iterator_tag iterator_category;
-    typedef Reference reference;
-    typedef T value_type;
-    typedef T* pointer;
-    typedef int difference_type;
-
-    SwigPySequence_InputIterator()
-    {
-    }
-
-    SwigPySequence_InputIterator(PyObject* seq, int index)
-      : _seq(seq), _index(index)
-    {
-    }
-
-    reference operator*() const
-    {
-      return reference(_seq, _index);
-    }
-
-    SwigPySequence_ArrowProxy<T>
-    operator->() const {
-      return SwigPySequence_ArrowProxy<T>(operator*());
-    }
-
-    bool operator==(const self& ri) const
-    {
-      return (_index == ri._index) && (_seq == ri._seq);
-    }
-
-    bool operator!=(const self& ri) const
-    {
-      return !(operator==(ri));
-    }
-
-    self& operator ++ ()
-    {
-      ++_index;
-      return *this;
-    }
-
-    self& operator -- ()
-    {
-      --_index;
-      return *this;
-    }
-
-    self& operator += (difference_type n)
-    {
-      _index += n;
-      return *this;
-    }
-
-    self operator +(difference_type n) const
-    {
-      return self(_seq, _index + n);
-    }
-
-    self& operator -= (difference_type n)
-    {
-      _index -= n;
-      return *this;
-    }
-
-    self operator -(difference_type n) const
-    {
-      return self(_seq, _index - n);
-    }
-
-    difference_type operator - (const self& ri) const
-    {
-      return _index - ri._index;
-    }
-
-    bool operator < (const self& ri) const
-    {
-      return _index < ri._index;
-    }
-
-    reference
-    operator[](difference_type n) const
-    {
-      return reference(_seq, _index + n);
-    }
-
-  private:
-    PyObject* _seq;
-    difference_type _index;
-  };
-
-  template <class T>
-  struct SwigPySequence_Cont
-  {
-    typedef SwigPySequence_Ref<T> reference;
-    typedef const SwigPySequence_Ref<T> const_reference;
-    typedef T value_type;
-    typedef T* pointer;
-    typedef int difference_type;
-    typedef int size_type;
-    typedef const pointer const_pointer;
-    typedef SwigPySequence_InputIterator<T, reference> iterator;
-    typedef SwigPySequence_InputIterator<T, const_reference> const_iterator;
-
-    SwigPySequence_Cont(PyObject* seq) : _seq(0)
-    {
-      if (!PySequence_Check(seq)) {
-	throw std::invalid_argument("a sequence is expected");
-      }
-      _seq = seq;
-      Py_INCREF(_seq);
-    }
-
-    ~SwigPySequence_Cont()
-    {
-      Py_XDECREF(_seq);
-    }
-
-    size_type size() const
-    {
-      return static_cast<size_type>(PySequence_Size(_seq));
-    }
-
-    bool empty() const
-    {
-      return size() == 0;
-    }
-
-    iterator begin()
-    {
-      return iterator(_seq, 0);
-    }
-
-    const_iterator begin() const
-    {
-      return const_iterator(_seq, 0);
-    }
-
-    iterator end()
-    {
-      return iterator(_seq, size());
-    }
-
-    const_iterator end() const
-    {
-      return const_iterator(_seq, size());
-    }
-
-    reference operator[](difference_type n)
-    {
-      return reference(_seq, n);
-    }
-
-    const_reference operator[](difference_type n)  const
-    {
-      return const_reference(_seq, n);
-    }
-
-    bool check(bool set_err = true) const
-    {
-      int s = size();
-      for (int i = 0; i < s; ++i) {
-	swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i);
-	if (!swig::check<value_type>(item)) {
-	  if (set_err) {
-	    char msg[1024];
-	    sprintf(msg, "in sequence element %d", i);
-	    SWIG_Error(SWIG_RuntimeError, msg);
-	  }
-	  return false;
-	}
-      }
-      return true;
-    }
-
-  private:
-    PyObject* _seq;
-  };
-
-}
-}
-
-%define %swig_sequence_iterator(Sequence...)
-#if defined(SWIG_EXPORT_ITERATOR_METHODS)
-  class iterator;
-  class reverse_iterator;
-  class const_iterator;
-  class const_reverse_iterator;
-
-  %typemap(out,noblock=1,fragment="SwigPySequence_Cont")
-    iterator, reverse_iterator, const_iterator, const_reverse_iterator {
-    $result = SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &)),
-				 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
-  }
-  %typemap(out,noblock=1,fragment="SwigPySequence_Cont")
-    std::pair<iterator, iterator>, std::pair<const_iterator, const_iterator> {
-    $result = PyTuple_New(2);
-    PyTuple_SetItem($result,0,SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &).first),
-						 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN));
-    PyTuple_SetItem($result,1,SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &).second),
-						 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN));    
-  }
-
-  %fragment("SwigPyPairBoolOutputIterator","header",fragment=SWIG_From_frag(bool),fragment="SwigPySequence_Cont") {}
-
-  %typemap(out,noblock=1,fragment="SwigPyPairBoolOutputIterator")
-    std::pair<iterator, bool>, std::pair<const_iterator, bool> {
-    $result = PyTuple_New(2);
-    PyTuple_SetItem($result,0,SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &).first),
-					       swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN));    
-    PyTuple_SetItem($result,1,SWIG_From(bool)(%static_cast($1,const $type &).second));
-  }
-
-  %typemap(in,noblock=1,fragment="SwigPySequence_Cont")
-    iterator(swig::SwigPyIterator *iter = 0, int res),
-    reverse_iterator(swig::SwigPyIterator *iter = 0, int res),
-    const_iterator(swig::SwigPyIterator *iter = 0, int res),
-    const_reverse_iterator(swig::SwigPyIterator *iter = 0, int res) {
-    res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
-    if (!SWIG_IsOK(res) || !iter) {
-      %argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
-    } else {
-      swig::SwigPyIterator_T<$type > *iter_t = dynamic_cast<swig::SwigPyIterator_T<$type > *>(iter);
-      if (iter_t) {
-	$1 = iter_t->get_current();
-      } else {
-	%argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
-      }
-    }
-  }
-
-  %typecheck(%checkcode(ITERATOR),noblock=1,fragment="SwigPySequence_Cont")
-    iterator, reverse_iterator, const_iterator, const_reverse_iterator {
-    swig::SwigPyIterator *iter = 0;
-    int res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
-    $1 = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<$type > *>(iter) != 0));
-  }
-
-  %fragment("SwigPySequence_Cont");
-
-  %newobject iterator(PyObject **PYTHON_SELF);
-  %extend  {
-    swig::SwigPyIterator* iterator(PyObject **PYTHON_SELF) {
-      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
-    }
-
-#if defined(SWIGPYTHON_BUILTIN)
-  %feature("python:slot", "tp_iter", functype="getiterfunc") iterator;
-#else
-  %pythoncode {def __iter__(self): return self.iterator()}
-#endif
-  }
-
-#endif //SWIG_EXPORT_ITERATOR_METHODS
-%enddef
-
-
-/**** The python container methods  ****/
-
-%define %swig_container_methods(Container...)
-
-/* deprecated in Python 2 */
-#if 1
-  %newobject __getslice__;
-#endif
-  %newobject __getitem__(PySliceObject *slice);
-
-#if defined(SWIGPYTHON_BUILTIN)
-  %feature("python:slot", "nb_nonzero", functype="inquiry") __nonzero__;
-  %feature("python:slot", "sq_length", functype="lenfunc") __len__;
-#endif // SWIGPYTHON_BUILTIN
-
-  %extend {
-    bool __nonzero__() const {
-      return !(self->empty());
-    }
-
-    /* Alias for Python 3 compatibility */
-    bool __bool__() const {
-      return !(self->empty());
-    }
-
-    size_type __len__() const {
-      return self->size();
-    }
-  }
-
-%enddef
-
-
-
-%define %swig_sequence_methods_common(Sequence...)
-  %swig_sequence_iterator(%arg(Sequence))
-  %swig_container_methods(%arg(Sequence))
-  
-  %fragment("SwigPySequence_Base");
-
-#if defined(SWIGPYTHON_BUILTIN)
-  //%feature("python:slot", "sq_item", functype="ssizeargfunc") __getitem__;
-  //%feature("python:slot", "sq_slice", functype="ssizessizeargfunc") __getslice__;
-  //%feature("python:slot", "sq_ass_item", functype="ssizeobjargproc") __setitem__;
-  //%feature("python:slot", "sq_ass_slice", functype="ssizessizeobjargproc") __setslice__;
-  %feature("python:slot", "mp_subscript", functype="binaryfunc") __getitem__;
-  %feature("python:slot", "mp_ass_subscript", functype="objobjargproc") __setitem__;
-#endif // SWIGPYTHON_BUILTIN
-
-  %extend {
-    value_type pop() throw (std::out_of_range) {
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      Sequence::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
-
-    /* typemap for slice object support */
-    %typemap(in) PySliceObject* {
-      if (!PySlice_Check($input)) {
-        %argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
-      }
-      $1 = (PySliceObject *) $input;
-    }
-    %typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER) PySliceObject* {
-      $1 = PySlice_Check($input);
-    }
-
-/* deprecated in Python 2 */
-#if 1
-    Sequence* __getslice__(difference_type i, difference_type j) throw (std::out_of_range, std::invalid_argument) {
-      return swig::getslice(self, i, j, 1);
-    }
-
-    void __setslice__(difference_type i, difference_type j, const Sequence& v = Sequence()) throw (std::out_of_range, std::invalid_argument) {
-      swig::setslice(self, i, j, 1, v);
-    }
-
-    void __delslice__(difference_type i, difference_type j) throw (std::out_of_range, std::invalid_argument) {
-      swig::delslice(self, i, j, 1);
-    }
-#endif
-
-    void __delitem__(difference_type i) throw (std::out_of_range) {
-      self->erase(swig::getpos(self,i));
-    }
-
-
-    /* Overloaded methods for Python 3 compatibility 
-     * (Also useful in Python 2.x)
-     */
-    Sequence* __getitem__(PySliceObject *slice) throw (std::out_of_range, std::invalid_argument) {
-      Py_ssize_t i, j, step;
-      if( !PySlice_Check(slice) ) {
-        SWIG_Error(SWIG_TypeError, "Slice object expected.");
-        return NULL;
-      }
-      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      Sequence::difference_type id = i;
-      Sequence::difference_type jd = j;
-      return swig::getslice(self, id, jd, step);
-    }
-
-    void __setitem__(PySliceObject *slice, const Sequence& v) throw (std::out_of_range, std::invalid_argument) {
-      Py_ssize_t i, j, step;
-      if( !PySlice_Check(slice) ) {
-        SWIG_Error(SWIG_TypeError, "Slice object expected.");
-        return;
-      }
-      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      Sequence::difference_type id = i;
-      Sequence::difference_type jd = j;
-      swig::setslice(self, id, jd, step, v);
-    }
-
-    void __setitem__(PySliceObject *slice) throw (std::out_of_range, std::invalid_argument) {
-      Py_ssize_t i, j, step;
-      if( !PySlice_Check(slice) ) {
-        SWIG_Error(SWIG_TypeError, "Slice object expected.");
-        return;
-      }
-      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      Sequence::difference_type id = i;
-      Sequence::difference_type jd = j;
-      swig::delslice(self, id, jd, step);
-    }
-
-    void __delitem__(PySliceObject *slice) throw (std::out_of_range, std::invalid_argument) {
-      Py_ssize_t i, j, step;
-      if( !PySlice_Check(slice) ) {
-        SWIG_Error(SWIG_TypeError, "Slice object expected.");
-        return;
-      }
-      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      Sequence::difference_type id = i;
-      Sequence::difference_type jd = j;
-      swig::delslice(self, id, jd, step);
-    }
-     
-  }
-
-%enddef
-
-%define %swig_sequence_methods(Sequence...)
-  %swig_sequence_methods_common(%arg(Sequence))
-  %extend {
-    const value_type& __getitem__(difference_type i) const throw (std::out_of_range) {
-      return *(swig::cgetpos(self, i));
-    }
-
-    void __setitem__(difference_type i, const value_type& x) throw (std::out_of_range) {
-      *(swig::getpos(self,i)) = x;
-    }
-
-    void append(const value_type& x) {
-      self->push_back(x);
-    }
- }
-
-%enddef
-
-%define %swig_sequence_methods_val(Sequence...)
-  %swig_sequence_methods_common(%arg(Sequence))
-  %extend {
-    value_type __getitem__(difference_type i) throw (std::out_of_range) {
-      return *(swig::cgetpos(self, i));
-    }
-
-    void __setitem__(difference_type i, value_type x) throw (std::out_of_range) {
-      *(swig::getpos(self,i)) = x;
-    }
-
-    void append(value_type x) {
-      self->push_back(x);
-    }
- }
-
-%enddef
-
-
-
-//
-// Common fragments
-//
-
-%fragment("StdSequenceTraits","header",
-	  fragment="StdTraits",
-	  fragment="SwigPySequence_Cont")
-{
-namespace swig {
-  template <class SwigPySeq, class Seq>
-  inline void
-  assign(const SwigPySeq& swigpyseq, Seq* seq) {
-    // seq->assign(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented
-    typedef typename SwigPySeq::value_type value_type;
-    typename SwigPySeq::const_iterator it = swigpyseq.begin();
-    for (;it != swigpyseq.end(); ++it) {
-      seq->insert(seq->end(),(value_type)(*it));
-    }
-  }
-
-  template <class Seq, class T = typename Seq::value_type >
-  struct traits_asptr_stdseq {
-    typedef Seq sequence;
-    typedef T value_type;
-
-    static int asptr(PyObject *obj, sequence **seq) {
-      if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) {
-	sequence *p;
-	if (::SWIG_ConvertPtr(obj,(void**)&p,
-			      swig::type_info<sequence>(),0) == SWIG_OK) {
-	  if (seq) *seq = p;
-	  return SWIG_OLDOBJ;
-	}
-      } else if (PySequence_Check(obj)) {
-	try {
-	  SwigPySequence_Cont<value_type> swigpyseq(obj);
-	  if (seq) {
-	    sequence *pseq = new sequence();
-	    assign(swigpyseq, pseq);
-	    *seq = pseq;
-	    return SWIG_NEWOBJ;
-	  } else {
-	    return swigpyseq.check() ? SWIG_OK : SWIG_ERROR;
-	  }
-	} catch (std::exception& e) {
-	  if (seq) {
-	    if (!PyErr_Occurred()) {
-	      PyErr_SetString(PyExc_TypeError, e.what());
-	    }
-	  }
-	  return SWIG_ERROR;
-	}
-      }
-      return SWIG_ERROR;
-    }
-  };
-
-  template <class Seq, class T = typename Seq::value_type >
-  struct traits_from_stdseq {
-    typedef Seq sequence;
-    typedef T value_type;
-    typedef typename Seq::size_type size_type;
-    typedef typename sequence::const_iterator const_iterator;
-
-    static PyObject *from(const sequence& seq) {
-%#ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS
-      swig_type_info *desc = swig::type_info<sequence>();
-      if (desc && desc->clientdata) {
-	return SWIG_NewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
-      }
-%#endif
-      size_type size = seq.size();
-      if (size <= (size_type)INT_MAX) {
-	PyObject *obj = PyTuple_New((int)size);
-	int i = 0;
-	for (const_iterator it = seq.begin();
-	     it != seq.end(); ++it, ++i) {
-	  PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
-	}
-	return obj;
-      } else {
-	PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python");
-	return NULL;
-      }
-    }
-  };
-}
-}
diff --git a/share/swig/2.0.11/python/pydocs.swg b/share/swig/2.0.11/python/pydocs.swg
deleted file mode 100644
index f4ab9db..0000000
--- a/share/swig/2.0.11/python/pydocs.swg
+++ /dev/null
@@ -1,22 +0,0 @@
-
-// Documentation for use with the autodoc feature.
-
-#ifdef SWIG_DOC_DOXYGEN_STYLE
-%typemap(doc) SWIGTYPE "@param $1_name $1_type";
-%typemap(doc) SWIGTYPE * "@param $1_name $1_type";
-%typemap(doc) const SWIGTYPE & "@param $1_name $1_type";
-%typemap(doc) enum SWIGTYPE "@param $1_name enum $1_type";
-
-%typemap(doc) SWIGTYPE *INOUT, SWIGTYPE &INOUT "@param $1_name $1_type (input/output)";
-%typemap(doc) SWIGTYPE *INPUT, SWIGTYPE &INPUT "@param $1_name $1_type (input)";
-%typemap(doc) SWIGTYPE *OUTPUT, SWIGTYPE &OUTPUT "@param $1_name $1_type (output)";
-#else
-%typemap(doc) SWIGTYPE "$1_name: $1_type";
-%typemap(doc) SWIGTYPE * "$1_name: $1_type";
-%typemap(doc) const SWIGTYPE & "$1_name: $1_type";
-%typemap(doc) enum SWIGTYPE "$1_name: enum $1_type";
-
-%typemap(doc) SWIGTYPE *INOUT, SWIGTYPE &INOUT "$1_name: $1_type (input/output)";
-%typemap(doc) SWIGTYPE *INPUT, SWIGTYPE &INPUT "$1_name: $1_type (input)";
-%typemap(doc) SWIGTYPE *OUTPUT, SWIGTYPE &OUTPUT "$1_name: $1_type (output)";
-#endif
diff --git a/share/swig/2.0.11/python/pyhead.swg b/share/swig/2.0.11/python/pyhead.swg
deleted file mode 100644
index cedd017..0000000
--- a/share/swig/2.0.11/python/pyhead.swg
+++ /dev/null
@@ -1,218 +0,0 @@
-/* Compatibility macros for Python 3 */
-#if PY_VERSION_HEX >= 0x03000000
-
-#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
-#define PyInt_Check(x) PyLong_Check(x)
-#define PyInt_AsLong(x) PyLong_AsLong(x)
-#define PyInt_FromLong(x) PyLong_FromLong(x)
-#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
-#define PyString_Check(name) PyBytes_Check(name)
-#define PyString_FromString(x) PyUnicode_FromString(x)
-#define PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)
-#define PyString_AsString(str) PyBytes_AsString(str)
-#define PyString_Size(str) PyBytes_Size(str)	
-#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
-#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
-#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
-#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
-
-#endif
-
-#ifndef Py_TYPE
-#  define Py_TYPE(op) ((op)->ob_type)
-#endif
-
-/* SWIG APIs for compatibility of both Python 2 & 3 */
-
-#if PY_VERSION_HEX >= 0x03000000
-#  define SWIG_Python_str_FromFormat PyUnicode_FromFormat
-#else
-#  define SWIG_Python_str_FromFormat PyString_FromFormat
-#endif
-
-
-/* Warning: This function will allocate a new string in Python 3,
- * so please call SWIG_Python_str_DelForPy3(x) to free the space.
- */
-SWIGINTERN char*
-SWIG_Python_str_AsChar(PyObject *str)
-{
-#if PY_VERSION_HEX >= 0x03000000
-  char *cstr;
-  char *newstr;
-  Py_ssize_t len;
-  str = PyUnicode_AsUTF8String(str);
-  PyBytes_AsStringAndSize(str, &cstr, &len);
-  newstr = (char *) malloc(len+1);
-  memcpy(newstr, cstr, len+1);
-  Py_XDECREF(str);
-  return newstr;
-#else
-  return PyString_AsString(str);
-#endif
-}
-
-#if PY_VERSION_HEX >= 0x03000000
-#  define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
-#else
-#  define SWIG_Python_str_DelForPy3(x) 
-#endif
-
-
-SWIGINTERN PyObject*
-SWIG_Python_str_FromChar(const char *c)
-{
-#if PY_VERSION_HEX >= 0x03000000
-  return PyUnicode_FromString(c); 
-#else
-  return PyString_FromString(c);
-#endif
-}
-
-/* Add PyOS_snprintf for old Pythons */
-#if PY_VERSION_HEX < 0x02020000
-# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
-#  define PyOS_snprintf _snprintf
-# else
-#  define PyOS_snprintf snprintf
-# endif
-#endif
-
-/* A crude PyString_FromFormat implementation for old Pythons */
-#if PY_VERSION_HEX < 0x02020000
-
-#ifndef SWIG_PYBUFFER_SIZE
-# define SWIG_PYBUFFER_SIZE 1024
-#endif
-
-static PyObject *
-PyString_FromFormat(const char *fmt, ...) {
-  va_list ap;
-  char buf[SWIG_PYBUFFER_SIZE * 2];
-  int res;
-  va_start(ap, fmt);
-  res = vsnprintf(buf, sizeof(buf), fmt, ap);
-  va_end(ap);
-  return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
-}
-#endif
-
-/* Add PyObject_Del for old Pythons */
-#if PY_VERSION_HEX < 0x01060000
-# define PyObject_Del(op) PyMem_DEL((op))
-#endif
-#ifndef PyObject_DEL
-# define PyObject_DEL PyObject_Del
-#endif
-
-/* A crude PyExc_StopIteration exception for old Pythons */
-#if PY_VERSION_HEX < 0x02020000
-# ifndef PyExc_StopIteration
-#  define PyExc_StopIteration PyExc_RuntimeError
-# endif
-# ifndef PyObject_GenericGetAttr
-#  define PyObject_GenericGetAttr 0
-# endif
-#endif
-
-/* Py_NotImplemented is defined in 2.1 and up. */
-#if PY_VERSION_HEX < 0x02010000
-# ifndef Py_NotImplemented
-#  define Py_NotImplemented PyExc_RuntimeError
-# endif
-#endif
-
-/* A crude PyString_AsStringAndSize implementation for old Pythons */
-#if PY_VERSION_HEX < 0x02010000
-# ifndef PyString_AsStringAndSize
-#  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
-# endif
-#endif
-
-/* PySequence_Size for old Pythons */
-#if PY_VERSION_HEX < 0x02000000
-# ifndef PySequence_Size
-#  define PySequence_Size PySequence_Length
-# endif
-#endif
-
-/* PyBool_FromLong for old Pythons */
-#if PY_VERSION_HEX < 0x02030000
-static
-PyObject *PyBool_FromLong(long ok)
-{
-  PyObject *result = ok ? Py_True : Py_False;
-  Py_INCREF(result);
-  return result;
-}
-#endif
-
-/* Py_ssize_t for old Pythons */
-/* This code is as recommended by: */
-/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
-#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
-typedef int Py_ssize_t;
-# define PY_SSIZE_T_MAX INT_MAX
-# define PY_SSIZE_T_MIN INT_MIN
-typedef inquiry lenfunc;
-typedef intargfunc ssizeargfunc;
-typedef intintargfunc ssizessizeargfunc;
-typedef intobjargproc ssizeobjargproc;
-typedef intintobjargproc ssizessizeobjargproc;
-typedef getreadbufferproc readbufferproc;
-typedef getwritebufferproc writebufferproc;
-typedef getsegcountproc segcountproc;
-typedef getcharbufferproc charbufferproc;
-static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
-{
-  long result = 0;
-  PyObject *i = PyNumber_Int(x);
-  if (i) {
-    result = PyInt_AsLong(i);
-    Py_DECREF(i);
-  }
-  return result;
-}
-#endif
-
-#if PY_VERSION_HEX < 0x02050000
-#define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
-#endif
-
-#if PY_VERSION_HEX < 0x02040000
-#define Py_VISIT(op)				\
-  do { 						\
-    if (op) {					\
-      int vret = visit((op), arg);		\
-      if (vret)					\
-        return vret;				\
-    }						\
-  } while (0)
-#endif
-
-#if PY_VERSION_HEX < 0x02030000
-typedef struct {
-  PyTypeObject type;
-  PyNumberMethods as_number;
-  PyMappingMethods as_mapping;
-  PySequenceMethods as_sequence;
-  PyBufferProcs as_buffer;
-  PyObject *name, *slots;
-} PyHeapTypeObject;
-#endif
-
-#if PY_VERSION_HEX < 0x02030000
-typedef destructor freefunc;
-#endif
-
-#if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
-     (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
-     (PY_MAJOR_VERSION > 3))
-# define SWIGPY_USE_CAPSULE
-# define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
-#endif
-
-#if PY_VERSION_HEX < 0x03020000
-#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
-#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
-#endif
diff --git a/share/swig/2.0.11/python/pyinit.swg b/share/swig/2.0.11/python/pyinit.swg
deleted file mode 100644
index 6a6de09..0000000
--- a/share/swig/2.0.11/python/pyinit.swg
+++ /dev/null
@@ -1,443 +0,0 @@
-/* ------------------------------------------------------------
- * The start of the Python initialization function 
- * ------------------------------------------------------------ */
-
-%insert(init) "swiginit.swg"
-
-%init %{
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Python-specific SWIG API */
-#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
-#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
-#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
- 
-/* -----------------------------------------------------------------------------
- * global variable support code.
- * ----------------------------------------------------------------------------- */
- 
-typedef struct swig_globalvar {   
-  char       *name;                  /* Name of global variable */
-  PyObject *(*get_attr)(void);       /* Return the current value */
-  int       (*set_attr)(PyObject *); /* Set the value */
-  struct swig_globalvar *next;
-} swig_globalvar;
-
-typedef struct swig_varlinkobject {
-  PyObject_HEAD
-  swig_globalvar *vars;
-} swig_varlinkobject;
-
-SWIGINTERN PyObject *
-swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
-#if PY_VERSION_HEX >= 0x03000000
-  return PyUnicode_InternFromString("<Swig global variables>");
-#else
-  return PyString_FromString("<Swig global variables>");
-#endif
-}
-
-SWIGINTERN PyObject *
-swig_varlink_str(swig_varlinkobject *v) {
-#if PY_VERSION_HEX >= 0x03000000
-  PyObject *str = PyUnicode_InternFromString("(");
-  PyObject *tail;
-  PyObject *joined;
-  swig_globalvar *var;
-  for (var = v->vars; var; var=var->next) {
-    tail = PyUnicode_FromString(var->name);
-    joined = PyUnicode_Concat(str, tail);
-    Py_DecRef(str);
-    Py_DecRef(tail);
-    str = joined;
-    if (var->next) {
-        tail = PyUnicode_InternFromString(", ");
-        joined = PyUnicode_Concat(str, tail);
-        Py_DecRef(str);
-        Py_DecRef(tail);
-        str = joined;
-    }
-  }
-  tail = PyUnicode_InternFromString(")");
-  joined = PyUnicode_Concat(str, tail);
-  Py_DecRef(str);
-  Py_DecRef(tail);
-  str = joined;
-#else
-  PyObject *str = PyString_FromString("(");
-  swig_globalvar *var;
-  for (var = v->vars; var; var=var->next) {
-    PyString_ConcatAndDel(&str,PyString_FromString(var->name));
-    if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
-  }
-  PyString_ConcatAndDel(&str,PyString_FromString(")"));
-#endif
-  return str;
-}
-
-SWIGINTERN int
-swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
-  char *tmp;
-  PyObject *str = swig_varlink_str(v);
-  fprintf(fp,"Swig global variables ");
-  fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
-  SWIG_Python_str_DelForPy3(tmp);
-  Py_DECREF(str);
-  return 0;
-}
-
-SWIGINTERN void
-swig_varlink_dealloc(swig_varlinkobject *v) {
-  swig_globalvar *var = v->vars;
-  while (var) {
-    swig_globalvar *n = var->next;
-    free(var->name);
-    free(var);
-    var = n;
-  }
-}
-
-SWIGINTERN PyObject *
-swig_varlink_getattr(swig_varlinkobject *v, char *n) {
-  PyObject *res = NULL;
-  swig_globalvar *var = v->vars;
-  while (var) {
-    if (strcmp(var->name,n) == 0) {
-      res = (*var->get_attr)();
-      break;
-    }
-    var = var->next;
-  }
-  if (res == NULL && !PyErr_Occurred()) {
-    PyErr_SetString(PyExc_NameError,"Unknown C global variable");
-  }
-  return res;
-}
-
-SWIGINTERN int
-swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
-  int res = 1;
-  swig_globalvar *var = v->vars;
-  while (var) {
-    if (strcmp(var->name,n) == 0) {
-      res = (*var->set_attr)(p);
-      break;
-    }
-    var = var->next;
-  }
-  if (res == 1 && !PyErr_Occurred()) {
-    PyErr_SetString(PyExc_NameError,"Unknown C global variable");
-  }
-  return res;
-}
-
-SWIGINTERN PyTypeObject*
-swig_varlink_type(void) {
-  static char varlink__doc__[] = "Swig var link object";
-  static PyTypeObject varlink_type;
-  static int type_init = 0;
-  if (!type_init) {
-    const PyTypeObject tmp = {
-      /* PyObject header changed in Python 3 */
-#if PY_VERSION_HEX >= 0x03000000
-      PyVarObject_HEAD_INIT(NULL, 0)
-#else
-      PyObject_HEAD_INIT(NULL)
-      0,                                  /* ob_size */
-#endif
-      (char *)"swigvarlink",              /* tp_name */
-      sizeof(swig_varlinkobject),         /* tp_basicsize */
-      0,                                  /* tp_itemsize */
-      (destructor) swig_varlink_dealloc,  /* tp_dealloc */
-      (printfunc) swig_varlink_print,     /* tp_print */
-      (getattrfunc) swig_varlink_getattr, /* tp_getattr */
-      (setattrfunc) swig_varlink_setattr, /* tp_setattr */
-      0,                                  /* tp_compare */
-      (reprfunc) swig_varlink_repr,       /* tp_repr */
-      0,                                  /* tp_as_number */
-      0,                                  /* tp_as_sequence */
-      0,                                  /* tp_as_mapping */
-      0,                                  /* tp_hash */
-      0,                                  /* tp_call */
-      (reprfunc) swig_varlink_str,        /* tp_str */
-      0,                                  /* tp_getattro */
-      0,                                  /* tp_setattro */
-      0,                                  /* tp_as_buffer */
-      0,                                  /* tp_flags */
-      varlink__doc__,                     /* tp_doc */
-      0,                                  /* tp_traverse */
-      0,                                  /* tp_clear */
-      0,                                  /* tp_richcompare */
-      0,                                  /* tp_weaklistoffset */
-#if PY_VERSION_HEX >= 0x02020000
-      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
-#endif
-#if PY_VERSION_HEX >= 0x02030000
-      0,                                  /* tp_del */
-#endif
-#if PY_VERSION_HEX >= 0x02060000
-      0,                                  /* tp_version */
-#endif
-#ifdef COUNT_ALLOCS
-      0,0,0,0                             /* tp_alloc -> tp_next */
-#endif
-    };
-    varlink_type = tmp;
-    type_init = 1;
-#if PY_VERSION_HEX < 0x02020000
-    varlink_type.ob_type = &PyType_Type;
-#else
-    if (PyType_Ready(&varlink_type) < 0)
-      return NULL;
-#endif
-  }
-  return &varlink_type;
-}
-
-/* Create a variable linking object for use later */
-SWIGINTERN PyObject *
-SWIG_Python_newvarlink(void) {
-  swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
-  if (result) {
-    result->vars = 0;
-  }
-  return ((PyObject*) result);
-}
-
-SWIGINTERN void 
-SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
-  swig_varlinkobject *v = (swig_varlinkobject *) p;
-  swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
-  if (gv) {
-    size_t size = strlen(name)+1;
-    gv->name = (char *)malloc(size);
-    if (gv->name) {
-      strncpy(gv->name,name,size);
-      gv->get_attr = get_attr;
-      gv->set_attr = set_attr;
-      gv->next = v->vars;
-    }
-  }
-  v->vars = gv;
-}
-
-SWIGINTERN PyObject *
-SWIG_globals(void) {
-  static PyObject *_SWIG_globals = 0; 
-  if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();  
-  return _SWIG_globals;
-}
-
-/* -----------------------------------------------------------------------------
- * constants/methods manipulation
- * ----------------------------------------------------------------------------- */
-
-/* Install Constants */
-SWIGINTERN void
-SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
-  PyObject *obj = 0;
-  size_t i;
-  for (i = 0; constants[i].type; ++i) {
-    switch(constants[i].type) {
-    case SWIG_PY_POINTER:
-      obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
-      break;
-    case SWIG_PY_BINARY:
-      obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
-      break;
-    default:
-      obj = 0;
-      break;
-    }
-    if (obj) {
-      PyDict_SetItemString(d, constants[i].name, obj);
-      Py_DECREF(obj);
-    }
-  }
-}
-
-/* -----------------------------------------------------------------------------*/
-/* Fix SwigMethods to carry the callback ptrs when needed */
-/* -----------------------------------------------------------------------------*/
-
-SWIGINTERN void
-SWIG_Python_FixMethods(PyMethodDef *methods,
-		       swig_const_info *const_table,
-		       swig_type_info **types,
-		       swig_type_info **types_initial) {
-  size_t i;
-  for (i = 0; methods[i].ml_name; ++i) {
-    const char *c = methods[i].ml_doc;
-    if (c && (c = strstr(c, "swig_ptr: "))) {
-      int j;
-      swig_const_info *ci = 0;
-      const char *name = c + 10;
-      for (j = 0; const_table[j].type; ++j) {
-	if (strncmp(const_table[j].name, name, 
-		    strlen(const_table[j].name)) == 0) {
-	  ci = &(const_table[j]);
-	  break;
-	}
-      }
-      if (ci) {
-	void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
-	if (ptr) {
-	  size_t shift = (ci->ptype) - types;
-	  swig_type_info *ty = types_initial[shift];
-	  size_t ldoc = (c - methods[i].ml_doc);
-	  size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
-	  char *ndoc = (char*)malloc(ldoc + lptr + 10);
-	  if (ndoc) {
-	    char *buff = ndoc;
-	    strncpy(buff, methods[i].ml_doc, ldoc);
-	    buff += ldoc;
-	    strncpy(buff, "swig_ptr: ", 10);
-	    buff += 10;
-	    SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
-	    methods[i].ml_doc = ndoc;
-	  }
-	}
-      }
-    }
-  }
-} 
-
-#ifdef __cplusplus
-}
-#endif
-
-/* -----------------------------------------------------------------------------*
- *  Partial Init method
- * -----------------------------------------------------------------------------*/
-
-#ifdef __cplusplus
-extern "C"
-#endif
-
-SWIGEXPORT 
-#if PY_VERSION_HEX >= 0x03000000
-  PyObject*
-#else
-  void
-#endif
-SWIG_init(void) {
-  PyObject *m, *d, *md;
-#if PY_VERSION_HEX >= 0x03000000
-  static struct PyModuleDef SWIG_module = {
-# if PY_VERSION_HEX >= 0x03020000
-    PyModuleDef_HEAD_INIT,
-# else
-    {
-      PyObject_HEAD_INIT(NULL)
-      NULL, /* m_init */
-      0,    /* m_index */
-      NULL, /* m_copy */
-    },
-# endif
-    (char *) SWIG_name,
-    NULL,
-    -1,
-    SwigMethods,
-    NULL,
-    NULL,
-    NULL,
-    NULL
-  };
-#endif
-
-#if defined(SWIGPYTHON_BUILTIN)
-  static SwigPyClientData SwigPyObject_clientdata = {0, 0, 0, 0, 0, 0, 0};
-  static PyGetSetDef this_getset_def = {
-    (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
-  };
-  static SwigPyGetSet thisown_getset_closure = {
-    (PyCFunction) SwigPyObject_own,
-    (PyCFunction) SwigPyObject_own
-  };
-  static PyGetSetDef thisown_getset_def = {
-    (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
-  };
-  PyObject *metatype_args;
-  PyTypeObject *builtin_pytype;
-  int builtin_base_count;
-  swig_type_info *builtin_basetype;
-  PyObject *tuple;
-  PyGetSetDescrObject *static_getset;
-  PyTypeObject *metatype;
-  SwigPyClientData *cd;
-  PyObject *public_interface, *public_symbol;
-  PyObject *this_descr;
-  PyObject *thisown_descr;
-  int i;
-
-  (void)builtin_pytype;
-  (void)builtin_base_count;
-  (void)builtin_basetype;
-  (void)tuple;
-  (void)static_getset;
-
-  /* metatype is used to implement static member variables. */
-  metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
-  assert(metatype_args);
-  metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
-  assert(metatype);
-  Py_DECREF(metatype_args);
-  metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
-  assert(PyType_Ready(metatype) >= 0);
-#endif
-
-  /* Fix SwigMethods to carry the callback ptrs when needed */
-  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
-
-#if PY_VERSION_HEX >= 0x03000000
-  m = PyModule_Create(&SWIG_module);
-#else
-  m = Py_InitModule((char *) SWIG_name, SwigMethods);
-#endif
-  md = d = PyModule_GetDict(m);
-  (void)md;
-
-  SWIG_InitializeModule(0);
-
-#ifdef SWIGPYTHON_BUILTIN
-  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
-  assert(SwigPyObject_stype);
-  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
-  if (!cd) {
-    SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
-    SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce();
-  } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) {
-    PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
-# if PY_VERSION_HEX >= 0x03000000
-    return NULL;
-# else
-    return;
-# endif
-  }
-
-  /* All objects have a 'this' attribute */
-  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
-  (void)this_descr;
-
-  /* All objects have a 'thisown' attribute */
-  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
-  (void)thisown_descr;
-
-  public_interface = PyList_New(0);
-  public_symbol = 0;
-  (void)public_symbol;
-
-  PyDict_SetItemString(md, "__all__", public_interface);
-  Py_DECREF(public_interface);
-  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
-    SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
-  for (i = 0; swig_const_table[i].name != 0; ++i)
-    SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
-#endif
-
-  SWIG_InstallConstants(d,swig_const_table);
-%}
-
diff --git a/share/swig/2.0.11/python/pyiterators.swg b/share/swig/2.0.11/python/pyiterators.swg
deleted file mode 100644
index f93594c..0000000
--- a/share/swig/2.0.11/python/pyiterators.swg
+++ /dev/null
@@ -1,404 +0,0 @@
-/* -----------------------------------------------------------------------------
- * pyiterators.swg
- *
- * Implement a python 'output' iterator for Python 2.2 or higher.
- *
- * Users can derive form the SwigPyIterator to implement their
- * own iterators. As an example (real one since we use it for STL/STD
- * containers), the template SwigPyIterator_T does the
- * implementation for generic C++ iterators.
- * ----------------------------------------------------------------------------- */
-
-%include <std_common.i>
-
-%fragment("SwigPyIterator","header",fragment="<stddef.h>") {
-namespace swig {
-  struct stop_iteration {
-  };
-
-  struct SwigPyIterator {
-  private:
-    SwigPtr_PyObject _seq;
-
-  protected:
-    SwigPyIterator(PyObject *seq) : _seq(seq)
-    {
-    }
-      
-  public:
-    virtual ~SwigPyIterator() {}
-
-    // Access iterator method, required by Python
-    virtual PyObject *value() const = 0;
-
-    // Forward iterator method, required by Python
-    virtual SwigPyIterator *incr(size_t n = 1) = 0;
-    
-    // Backward iterator method, very common in C++, but not required in Python
-    virtual SwigPyIterator *decr(size_t /*n*/ = 1)
-    {
-      throw stop_iteration();
-    }
-
-    // Random access iterator methods, but not required in Python
-    virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const
-    {
-      throw std::invalid_argument("operation not supported");
-    }
-
-    virtual bool equal (const SwigPyIterator &/*x*/) const
-    {
-      throw std::invalid_argument("operation not supported");
-    }
-    
-    // C++ common/needed methods
-    virtual SwigPyIterator *copy() const = 0;
-
-    PyObject *next()     
-    {
-      SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
-      PyObject *obj = value();
-      incr();       
-      SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
-      return obj;     
-    }
-
-    /* Make an alias for Python 3.x */
-    PyObject *__next__()
-    {
-      return next();
-    }
-
-    PyObject *previous()
-    {
-      SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
-      decr();
-      PyObject *obj = value();
-      SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads       
-      return obj;
-    }
-
-    SwigPyIterator *advance(ptrdiff_t n)
-    {
-      return  (n > 0) ?  incr(n) : decr(-n);
-    }
-      
-    bool operator == (const SwigPyIterator& x)  const
-    {
-      return equal(x);
-    }
-      
-    bool operator != (const SwigPyIterator& x) const
-    {
-      return ! operator==(x);
-    }
-      
-    SwigPyIterator& operator += (ptrdiff_t n)
-    {
-      return *advance(n);
-    }
-
-    SwigPyIterator& operator -= (ptrdiff_t n)
-    {
-      return *advance(-n);
-    }
-      
-    SwigPyIterator* operator + (ptrdiff_t n) const
-    {
-      return copy()->advance(n);
-    }
-
-    SwigPyIterator* operator - (ptrdiff_t n) const
-    {
-      return copy()->advance(-n);
-    }
-      
-    ptrdiff_t operator - (const SwigPyIterator& x) const
-    {
-      return x.distance(*this);
-    }
-      
-    static swig_type_info* descriptor() {
-      static int init = 0;
-      static swig_type_info* desc = 0;
-      if (!init) {
-	desc = SWIG_TypeQuery("swig::SwigPyIterator *");
-	init = 1;
-      }	
-      return desc;
-    }    
-  };
-
-%#if defined(SWIGPYTHON_BUILTIN)
-  inline PyObject* make_output_iterator_builtin (PyObject *pyself)
-  {
-    Py_INCREF(pyself);
-    return pyself;
-  }
-%#endif
-}
-}
-
-%fragment("SwigPyIterator_T","header",fragment="<stddef.h>",fragment="SwigPyIterator",fragment="StdTraits",fragment="StdIteratorTraits") {
-namespace swig {
-  template<typename OutIterator>
-  class SwigPyIterator_T :  public SwigPyIterator
-  {
-  public:
-    typedef OutIterator out_iterator;
-    typedef typename std::iterator_traits<out_iterator>::value_type value_type;    
-    typedef SwigPyIterator_T<out_iterator> self_type;
-
-    SwigPyIterator_T(out_iterator curr, PyObject *seq)
-      : SwigPyIterator(seq), current(curr)
-    {
-    }
-
-    const out_iterator& get_current() const
-    {
-      return current;
-    }
-
-    
-    bool equal (const SwigPyIterator &iter) const
-    {
-      const self_type *iters = dynamic_cast<const self_type *>(&iter);
-      if (iters) {
-	return (current == iters->get_current());
-      } else {
-	throw std::invalid_argument("bad iterator type");
-      }
-    }
-    
-    ptrdiff_t distance(const SwigPyIterator &iter) const
-    {
-      const self_type *iters = dynamic_cast<const self_type *>(&iter);
-      if (iters) {
-	return std::distance(current, iters->get_current());
-      } else {
-	throw std::invalid_argument("bad iterator type");
-      }
-    }    
-    
-  protected:
-    out_iterator current;
-  };
-  
-  template <class ValueType>
-  struct from_oper 
-  {
-    typedef const ValueType& argument_type;
-    typedef PyObject *result_type;
-    result_type operator()(argument_type v) const
-    {
-      return swig::from(v);
-    }
-  };
-
-  template<typename OutIterator, 
-	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
-	   typename FromOper = from_oper<ValueType> >
-  class SwigPyIteratorOpen_T :  public SwigPyIterator_T<OutIterator>
-  {
-  public:
-    FromOper from;
-    typedef OutIterator out_iterator;
-    typedef ValueType value_type;
-    typedef SwigPyIterator_T<out_iterator>  base;
-    typedef SwigPyIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
-    
-    SwigPyIteratorOpen_T(out_iterator curr, PyObject *seq)
-      : SwigPyIterator_T<OutIterator>(curr, seq)
-    {
-    }
-    
-    PyObject *value() const {
-      return from(static_cast<const value_type&>(*(base::current)));
-    }
-    
-    SwigPyIterator *copy() const
-    {
-      return new self_type(*this);
-    }
-
-    SwigPyIterator *incr(size_t n = 1)
-    {
-      while (n--) {
-	++base::current;
-      }
-      return this;
-    }
-
-    SwigPyIterator *decr(size_t n = 1)
-    {
-      while (n--) {
-	--base::current;
-      }
-      return this;
-    }
-  };
-
-  template<typename OutIterator, 
-	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
-	   typename FromOper = from_oper<ValueType> >
-  class SwigPyIteratorClosed_T :  public SwigPyIterator_T<OutIterator>
-  {
-  public:
-    FromOper from;
-    typedef OutIterator out_iterator;
-    typedef ValueType value_type;
-    typedef SwigPyIterator_T<out_iterator>  base;    
-    typedef SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
-    
-    SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
-      : SwigPyIterator_T<OutIterator>(curr, seq), begin(first), end(last)
-    {
-    }
-    
-    PyObject *value() const {
-      if (base::current == end) {
-	throw stop_iteration();
-      } else {
-	return from(static_cast<const value_type&>(*(base::current)));
-      }
-    }
-    
-    SwigPyIterator *copy() const
-    {
-      return new self_type(*this);
-    }
-
-    SwigPyIterator *incr(size_t n = 1)
-    {
-      while (n--) {
-	if (base::current == end) {
-	  throw stop_iteration();
-	} else {
-	  ++base::current;
-	}
-      }
-      return this;
-    }
-
-    SwigPyIterator *decr(size_t n = 1)
-    {
-      while (n--) {
-	if (base::current == begin) {
-	  throw stop_iteration();
-	} else {
-	  --base::current;
-	}
-      }
-      return this;
-    }
-
-  private:
-    out_iterator begin;
-    out_iterator end;
-  };
-
-  template<typename OutIter>
-  inline SwigPyIterator*
-  make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
-  {
-    return new SwigPyIteratorClosed_T<OutIter>(current, begin, end, seq);
-  }
-
-  template<typename OutIter>
-  inline SwigPyIterator*
-  make_output_iterator(const OutIter& current, PyObject *seq = 0)
-  {
-    return new SwigPyIteratorOpen_T<OutIter>(current, seq);
-  }
-
-}
-}
-
-
-%fragment("SwigPyIterator");
-namespace swig 
-{
-  /*
-    Throw a StopIteration exception
-  */
-  %ignore stop_iteration;
-  struct stop_iteration {};
-  
-  %typemap(throws) stop_iteration {
-    (void)$1;
-    SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
-    SWIG_fail;
-  }
-
-  /* 
-     Mark methods that return new objects
-  */
-  %newobject SwigPyIterator::copy;
-  %newobject SwigPyIterator::operator + (ptrdiff_t n) const;
-  %newobject SwigPyIterator::operator - (ptrdiff_t n) const;
-
-  %nodirector SwigPyIterator;
-
-#if defined(SWIGPYTHON_BUILTIN)
-  %feature("python:tp_iter") SwigPyIterator "&swig::make_output_iterator_builtin";
-  %feature("python:slot", "tp_iternext", functype="iternextfunc") SwigPyIterator::__next__;
-#else
-  %extend SwigPyIterator {
-  %pythoncode {def __iter__(self): return self}
-  }
-#endif
-
-  %catches(swig::stop_iteration) SwigPyIterator::value() const;
-  %catches(swig::stop_iteration) SwigPyIterator::incr(size_t n = 1);
-  %catches(swig::stop_iteration) SwigPyIterator::decr(size_t n = 1);
-  %catches(std::invalid_argument) SwigPyIterator::distance(const SwigPyIterator &x) const;
-  %catches(std::invalid_argument) SwigPyIterator::equal (const SwigPyIterator &x) const;
-  %catches(swig::stop_iteration) SwigPyIterator::__next__();
-  %catches(swig::stop_iteration) SwigPyIterator::next();
-  %catches(swig::stop_iteration) SwigPyIterator::previous();
-  %catches(swig::stop_iteration) SwigPyIterator::advance(ptrdiff_t n);
-  %catches(swig::stop_iteration) SwigPyIterator::operator += (ptrdiff_t n);
-  %catches(swig::stop_iteration) SwigPyIterator::operator -= (ptrdiff_t n);
-  %catches(swig::stop_iteration) SwigPyIterator::operator + (ptrdiff_t n) const;
-  %catches(swig::stop_iteration) SwigPyIterator::operator - (ptrdiff_t n) const;
-
-  struct SwigPyIterator
-  {
-  protected:
-    SwigPyIterator(PyObject *seq);
-
-  public:
-    virtual ~SwigPyIterator();
-
-    // Access iterator method, required by Python
-    virtual PyObject *value() const = 0;
-
-    // Forward iterator method, required by Python
-    virtual SwigPyIterator *incr(size_t n = 1) = 0;
-    
-    // Backward iterator method, very common in C++, but not required in Python
-    virtual SwigPyIterator *decr(size_t n = 1);
-
-    // Random access iterator methods, but not required in Python
-    virtual ptrdiff_t distance(const SwigPyIterator &x) const;
-
-    virtual bool equal (const SwigPyIterator &x) const;
-    
-    // C++ common/needed methods
-    virtual SwigPyIterator *copy() const = 0;
-
-    PyObject *next();
-    PyObject *__next__();
-    PyObject *previous();
-    SwigPyIterator *advance(ptrdiff_t n);
-
-    bool operator == (const SwigPyIterator& x)  const;
-    bool operator != (const SwigPyIterator& x) const;
-    SwigPyIterator& operator += (ptrdiff_t n);
-    SwigPyIterator& operator -= (ptrdiff_t n);
-    SwigPyIterator* operator + (ptrdiff_t n) const;
-    SwigPyIterator* operator - (ptrdiff_t n) const;
-    ptrdiff_t operator - (const SwigPyIterator& x) const;
-  };
-}
-
diff --git a/share/swig/2.0.11/python/pyopers.swg b/share/swig/2.0.11/python/pyopers.swg
deleted file mode 100644
index ecbe783..0000000
--- a/share/swig/2.0.11/python/pyopers.swg
+++ /dev/null
@@ -1,235 +0,0 @@
-/* ------------------------------------------------------------
- * Overloaded operator support
-
- The directives in this file apply whether or not you use the
- -builtin option to SWIG, but operator overloads are particularly
- attractive when using -builtin, because they are much faster
- than named methods.
-
- If you're using the -builtin option to SWIG, and you want to define
- python operator overloads beyond the defaults defined in this file,
- here's what you need to know:
-
- There are two ways to define a python slot function: dispatch to a
- statically defined function; or dispatch to a method defined on the
- operand.
-
- To dispatch to a statically defined function, use %feature("python:<slot>"),
- where <slot> is the name of a field in a PyTypeObject, PyNumberMethods,
- PyMappingMethods, PySequenceMethods, or PyBufferProcs.  For example:
-
-   %{
-   
-   static long myHashFunc (PyObject *pyobj) {
-     MyClass *cobj;
-     // Convert pyobj to cobj
-     return (cobj->field1 * (cobj->field2 << 7));
-   }
-   
-   %}
-
-   %feature("python:tp_hash") MyClass "myHashFunc";
-
- NOTE: It is the responsibility of the programmer (that's you) to ensure
- that a statically defined slot function has the correct signature.
-
- If, instead, you want to dispatch to an instance method, you can
- use %feature("python:slot").  For example:
-
-   class MyClass {
-     public:
-       long myHashFunc () const;
-       ...
-   };
-   
-   %feature("python:slot", "tp_hash", functype="hashfunc") MyClass::myHashFunc;
-
- NOTE: Some python slots use a method signature which does not
- match the signature of SWIG-wrapped methods.  For those slots,
- SWIG will automatically generate a "closure" function to re-marshall
- the arguments before dispatching to the wrapped method.  Setting
- the "functype" attribute of the feature enables SWIG to generate
- a correct closure function.
-
- --------------------------------------------------------------
-
- The tp_richcompare slot is a special case: SWIG automatically generates
- a rich compare function for all wrapped types.  If a type defines C++
- operator overloads for comparison (operator==, operator<, etc.), they
- will be called from the generated rich compare function.  If you
- want to explicitly choose a method to handle a certain comparison
- operation, you may use %feature("python:slot") like this:
-
-   class MyClass {
-     public:
-       bool lessThan (const MyClass& x) const;
-       ...
-   };
-   
-   %feature("python:slot", "Py_LT") MyClass::lessThan;
-
- ... where "Py_LT" is one of the rich comparison opcodes defined in the
- python header file object.h.
-
- If there's no method defined to handle a particular comparsion operation,
- the default behavior is to compare pointer values of the wrapped
- C++ objects.
-
- --------------------------------------------------------------
-
-
- For more information about python slots, including their names and
- signatures, you may refer to the python documentation :
-
-   http://docs.python.org/c-api/typeobj.html
-
- * ------------------------------------------------------------ */
-
-
-#ifdef __cplusplus
-
-#if defined(SWIGPYTHON_BUILTIN)
-#define %pybinoperator(pyname,oper,functp,slt) %rename(pyname) oper; %pythonmaybecall oper; %feature("python:slot", #slt, functype=#functp) oper; %feature("python:slot", #slt, functype=#functp) pyname;
-#define %pycompare(pyname,oper,comptype) %rename(pyname) oper; %pythonmaybecall oper; %feature("python:compare", #comptype) oper; %feature("python:compare", #comptype) pyname;
-#else
-#define %pybinoperator(pyname,oper,functp,slt) %rename(pyname) oper; %pythonmaybecall oper
-#define %pycompare(pyname,oper,comptype) %pybinoperator(pyname,oper,,comptype)
-#endif
-
-%pybinoperator(__add__,      *::operator+,		binaryfunc, nb_add);
-%pybinoperator(__pos__,      *::operator+(),		unaryfunc, nb_positive);
-%pybinoperator(__pos__,      *::operator+() const,	unaryfunc, nb_positive);
-%pybinoperator(__sub__,      *::operator-,		binaryfunc, nb_subtract);
-%pybinoperator(__neg__,      *::operator-(),		unaryfunc, nb_negative);
-%pybinoperator(__neg__,      *::operator-() const,	unaryfunc, nb_negative);
-%pybinoperator(__mul__,      *::operator*,		binaryfunc, nb_multiply);
-%pybinoperator(__div__,      *::operator/,		binaryfunc, nb_div);
-%pybinoperator(__mod__,      *::operator%,		binaryfunc, nb_remainder);
-%pybinoperator(__lshift__,   *::operator<<,		binaryfunc, nb_lshift);
-%pybinoperator(__rshift__,   *::operator>>,		binaryfunc, nb_rshift);
-%pybinoperator(__and__,      *::operator&,		binaryfunc, nb_and);
-%pybinoperator(__or__,       *::operator|,		binaryfunc, nb_or);
-%pybinoperator(__xor__,      *::operator^,		binaryfunc, nb_xor);
-%pycompare(__lt__,           *::operator<,		Py_LT);
-%pycompare(__le__,           *::operator<=,		Py_LE);
-%pycompare(__gt__,           *::operator>,		Py_GT);
-%pycompare(__ge__,           *::operator>=,		Py_GE);
-%pycompare(__eq__,           *::operator==,		Py_EQ);
-%pycompare(__ne__,           *::operator!=,		Py_NE);
-
-%feature("python:slot", "nb_truediv", functype="binaryfunc") *::operator/;
-
-/* Special cases */
-%rename(__invert__)     *::operator~;
-%feature("python:slot", "nb_invert", functype="unaryfunc") *::operator~;
-%rename(__call__)       *::operator();
-%feature("python:slot", "tp_call", functype="ternarycallfunc") *::operator();
-
-#if defined(SWIGPYTHON_BUILTIN)
-%pybinoperator(__nonzero__,   *::operator bool,		inquiry, nb_nonzero);
-#else
-%feature("shadow")      *::operator bool %{
-def __nonzero__(self):
-    return $action(self)
-__bool__ = __nonzero__
-%};
-%rename(__nonzero__)    *::operator bool;
-#endif
-
-/* Ignored operators */
-%ignoreoperator(LNOT)       operator!;
-%ignoreoperator(LAND)       operator&&;
-%ignoreoperator(LOR)        operator||;
-%ignoreoperator(EQ)         *::operator=;
-%ignoreoperator(PLUSPLUS)   *::operator++;
-%ignoreoperator(MINUSMINUS) *::operator--;
-%ignoreoperator(ARROWSTAR)  *::operator->*;
-%ignoreoperator(INDEX)      *::operator[];
-
-/*
-  Inplace operator declarations.
-
-  They translate the inplace C++ operators (+=, -=, ...)  into the
-  corresponding python equivalents(__iadd__,__isub__), etc,
-  disabling the ownership of the input 'self' pointer, and assigning
-  it to the returning object:  
-
-     %feature("del") *::Operator;
-     %feature("new") *::Operator;
-  
-  This makes the most common case safe, ie:
-
-     A&  A::operator+=(int i) { ...; return *this; }
-    ^^^^                                    ^^^^^^
-
-  will work fine, even when the resulting python object shares the
-  'this' pointer with the input one. The input object is usually
-  deleted after the operation, including the shared 'this' pointer,
-  producing 'strange' seg faults, as reported by Lucriz
-  (lucriz@sitilandia.it).
-
-  If you have an interface that already takes care of that, ie, you
-  already are using inplace operators and you are not getting
-  seg. faults, with the new scheme you could end with 'free' elements
-  that never get deleted (maybe, not sure, it depends). But if that is
-  the case, you could recover the old behaviour using
-
-     %feature("del","") A::operator+=;
-     %feature("new","") A::operator+=;
-
-  which recovers the old behaviour for the class 'A', or if you are
-  100% sure your entire system works fine in the old way, use:
-
-    %feature("del","") *::operator+=;
-    %feature("new","") *::operator+=;
-
-*/
-
-#if defined(SWIGPYTHON_BUILTIN)
-#define %pyinplaceoper(SwigPyOper, Oper, functp, slt) %delobject Oper; %newobject Oper; %feature("python:slot", #slt, functype=#functp) Oper; %rename(SwigPyOper) Oper
-#else
-#define %pyinplaceoper(SwigPyOper, Oper, functp, slt) %delobject Oper; %newobject Oper; %rename(SwigPyOper) Oper
-#endif
-
-%pyinplaceoper(__iadd__   , *::operator +=,	binaryfunc, nb_inplace_add);
-%pyinplaceoper(__isub__   , *::operator -=,	binaryfunc, nb_inplace_subtract);
-%pyinplaceoper(__imul__   , *::operator *=,	binaryfunc, nb_inplace_multiply);
-%pyinplaceoper(__idiv__   , *::operator /=,	binaryfunc, nb_inplace_divide);
-%pyinplaceoper(__imod__   , *::operator %=,	binaryfunc, nb_inplace_remainder);
-%pyinplaceoper(__iand__   , *::operator &=,	binaryfunc, nb_inplace_and);
-%pyinplaceoper(__ior__    , *::operator |=,	binaryfunc, nb_inplace_or);
-%pyinplaceoper(__ixor__   , *::operator ^=,	binaryfunc, nb_inplace_xor);
-%pyinplaceoper(__ilshift__, *::operator <<=,	binaryfunc, nb_inplace_lshift);
-%pyinplaceoper(__irshift__, *::operator >>=,	binaryfunc, nb_inplace_rshift);
-
-
-/* Finally, in python we need to mark the binary operations to fail as
- 'maybecall' methods */
-
-#define %pybinopermaybecall(oper) %pythonmaybecall __ ## oper ## __;  %pythonmaybecall __r ## oper ## __
-
-%pybinopermaybecall(add);
-%pybinopermaybecall(pos);
-%pybinopermaybecall(pos);
-%pybinopermaybecall(sub);
-%pybinopermaybecall(neg);
-%pybinopermaybecall(neg);
-%pybinopermaybecall(mul);
-%pybinopermaybecall(div);
-%pybinopermaybecall(mod);
-%pybinopermaybecall(lshift);
-%pybinopermaybecall(rshift);
-%pybinopermaybecall(and);
-%pybinopermaybecall(or);
-%pybinopermaybecall(xor);
-%pybinopermaybecall(lt);
-%pybinopermaybecall(le);
-%pybinopermaybecall(gt);
-%pybinopermaybecall(ge);
-%pybinopermaybecall(eq);
-%pybinopermaybecall(ne);
-
-#endif
-
-
-
diff --git a/share/swig/2.0.11/python/pyprimtypes.swg b/share/swig/2.0.11/python/pyprimtypes.swg
deleted file mode 100644
index 66ff104..0000000
--- a/share/swig/2.0.11/python/pyprimtypes.swg
+++ /dev/null
@@ -1,327 +0,0 @@
-/* ------------------------------------------------------------
- * Primitive Types
- * ------------------------------------------------------------ */
-
-/* boolean */
-
-%fragment(SWIG_From_frag(bool),"header") {
-SWIGINTERNINLINE PyObject*
-  SWIG_From_dec(bool)(bool value)
-{
-  return PyBool_FromLong(value ? 1 : 0);
-}
-}
-
-%fragment(SWIG_AsVal_frag(bool),"header",
-	  fragment=SWIG_AsVal_frag(long)) {
-SWIGINTERN int
-SWIG_AsVal_dec(bool)(PyObject *obj, bool *val)
-{
-  int r = PyObject_IsTrue(obj);
-  if (r == -1)
-    return SWIG_ERROR;
-  if (val) *val = r ? true : false;
-  return SWIG_OK;
-}
-}
-
-/* int */
-
-%fragment(SWIG_From_frag(int),"header") {
-SWIGINTERNINLINE PyObject*
-  SWIG_From_dec(int)(int value)
-{
-  return PyInt_FromLong((long) value);
-}
-}
-
-/* unsigned int */
-
-%fragment(SWIG_From_frag(unsigned int),"header") {
-SWIGINTERNINLINE PyObject*
-  SWIG_From_dec(unsigned int)(unsigned int value)
-{
-  return PyInt_FromSize_t((size_t) value);
-}
-}
-
-/* long */
-
-%fragment(SWIG_From_frag(long),"header") {
-  %define_as(SWIG_From_dec(long),           PyLong_FromLong)
-}
-
-%fragment(SWIG_AsVal_frag(long),"header",
-	  fragment="SWIG_CanCastAsInteger") {
-SWIGINTERN int
-SWIG_AsVal_dec(long)(PyObject *obj, long* val)
-{
-  if (PyInt_Check(obj)) {
-    if (val) *val = PyInt_AsLong(obj);
-    return SWIG_OK;
-  } else if (PyLong_Check(obj)) {
-    long v = PyLong_AsLong(obj);
-    if (!PyErr_Occurred()) {
-      if (val) *val = v;
-      return SWIG_OK;
-    } else {
-      PyErr_Clear();
-    }
-  }
-%#ifdef SWIG_PYTHON_CAST_MODE
-  {
-    int dispatch = 0;
-    long v = PyInt_AsLong(obj);
-    if (!PyErr_Occurred()) {
-      if (val) *val = v;
-      return SWIG_AddCast(SWIG_OK);
-    } else {
-      PyErr_Clear();
-    }
-    if (!dispatch) {
-      double d;
-      int res = SWIG_AddCast(SWIG_AsVal(double)(obj,&d));
-      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
-	if (val) *val = (long)(d);
-	return res;
-      }
-    }
-  }
-%#endif
-  return SWIG_TypeError;
-}
-}
-
-/* unsigned long */
-
-%fragment(SWIG_From_frag(unsigned long),"header",
-	  fragment=SWIG_From_frag(long)) {
-SWIGINTERNINLINE PyObject* 
-SWIG_From_dec(unsigned long)(unsigned long value)
-{
-  return (value > LONG_MAX) ?
-    PyLong_FromUnsignedLong(value) : PyLong_FromLong(%numeric_cast(value,long)); 
-}
-}
-
-%fragment(SWIG_AsVal_frag(unsigned long),"header",
-	  fragment="SWIG_CanCastAsInteger") {
-SWIGINTERN int
-SWIG_AsVal_dec(unsigned long)(PyObject *obj, unsigned long *val) 
-{
-%#if PY_VERSION_HEX < 0x03000000
-  if (PyInt_Check(obj)) {
-    long v = PyInt_AsLong(obj);
-    if (v >= 0) {
-      if (val) *val = v;
-      return SWIG_OK;
-    } else {
-      return SWIG_OverflowError;
-    }
-  } else
-%#endif
-  if (PyLong_Check(obj)) {
-    unsigned long v = PyLong_AsUnsignedLong(obj);
-    if (!PyErr_Occurred()) {
-      if (val) *val = v;
-      return SWIG_OK;
-    } else {
-      PyErr_Clear();
-%#if PY_VERSION_HEX >= 0x03000000
-      {
-        long v = PyLong_AsLong(obj);
-        if (!PyErr_Occurred()) {
-          if (v < 0) {
-            return SWIG_OverflowError;
-          }
-        } else {
-          PyErr_Clear();
-        }
-      }
-%#endif
-    }
-  }
-%#ifdef SWIG_PYTHON_CAST_MODE
-  {
-    int dispatch = 0;
-    unsigned long v = PyLong_AsUnsignedLong(obj);
-    if (!PyErr_Occurred()) {
-      if (val) *val = v;
-      return SWIG_AddCast(SWIG_OK);
-    } else {
-      PyErr_Clear();
-    }
-    if (!dispatch) {
-      double d;
-      int res = SWIG_AddCast(SWIG_AsVal(double)(obj,&d));
-      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
-	if (val) *val = (unsigned long)(d);
-	return res;
-      }
-    }
-  }
-%#endif
-  return SWIG_TypeError;
-}
-}
-
-/* long long */
-
-%fragment(SWIG_From_frag(long long),"header",
-	  fragment=SWIG_From_frag(long),
-	  fragment="<limits.h>") {
-SWIGINTERNINLINE PyObject* 
-SWIG_From_dec(long long)(long long value)
-{
-  return ((value < LONG_MIN) || (value > LONG_MAX)) ?
-    PyLong_FromLongLong(value) : PyLong_FromLong(%numeric_cast(value,long)); 
-}
-}
-
-%fragment(SWIG_AsVal_frag(long long),"header",
-	  fragment=SWIG_AsVal_frag(long),
-	  fragment="SWIG_CanCastAsInteger",
-	  fragment="<limits.h>") {
-SWIGINTERN int
-SWIG_AsVal_dec(long long)(PyObject *obj, long long *val)
-{
-  int res = SWIG_TypeError;
-  if (PyLong_Check(obj)) {
-    long long v = PyLong_AsLongLong(obj);
-    if (!PyErr_Occurred()) {
-      if (val) *val = v;
-      return SWIG_OK;
-    } else {
-      PyErr_Clear();
-    }
-  } else {
-    long v;
-    res = SWIG_AsVal(long)(obj,&v);
-    if (SWIG_IsOK(res)) {
-      if (val) *val = v;
-      return res;
-    }
-  }
-%#ifdef SWIG_PYTHON_CAST_MODE
-  {
-    const double mant_max = 1LL << DBL_MANT_DIG;
-    const double mant_min = -mant_max;
-    double d;
-    res = SWIG_AsVal(double)(obj,&d);
-    if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
-      if (val) *val = (long long)(d);
-      return SWIG_AddCast(res);
-    }
-    res = SWIG_TypeError;
-  }
-%#endif
-  return res;
-}
-}
-
-/* unsigned long long */
-
-%fragment(SWIG_From_frag(unsigned long long),"header",
-	  fragment=SWIG_From_frag(long long),
-	  fragment="<limits.h>") {
-SWIGINTERNINLINE PyObject* 
-SWIG_From_dec(unsigned long long)(unsigned long long value)
-{
-  return (value > LONG_MAX) ?
-    PyLong_FromUnsignedLongLong(value) : PyLong_FromLong(%numeric_cast(value,long)); 
-}
-}
-
-%fragment(SWIG_AsVal_frag(unsigned long long),"header",
-	  fragment=SWIG_AsVal_frag(unsigned long),
-	  fragment="SWIG_CanCastAsInteger",
-	  fragment="<limits.h>") {
-SWIGINTERN int
-SWIG_AsVal_dec(unsigned long long)(PyObject *obj, unsigned long long *val)
-{
-  int res = SWIG_TypeError;
-  if (PyLong_Check(obj)) {
-    unsigned long long v = PyLong_AsUnsignedLongLong(obj);
-    if (!PyErr_Occurred()) {
-      if (val) *val = v;
-      return SWIG_OK;
-    } else {
-      PyErr_Clear();
-    }
-  } else {
-    unsigned long v;
-    res = SWIG_AsVal(unsigned long)(obj,&v);
-    if (SWIG_IsOK(res)) {
-      if (val) *val = v;
-      return res;
-    }
-  }
-%#ifdef SWIG_PYTHON_CAST_MODE
-  {
-    const double mant_max = 1LL << DBL_MANT_DIG;
-    double d;
-    res = SWIG_AsVal(double)(obj,&d);
-    if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
-      if (val) *val = (unsigned long long)(d);
-      return SWIG_AddCast(res);
-    }
-    res = SWIG_TypeError;
-  }
-%#endif
-  return res;
-}
-}
-
-/* double */
-
-%fragment(SWIG_From_frag(double),"header") {
-  %define_as(SWIG_From_dec(double),          PyFloat_FromDouble)
-}
-
-%fragment(SWIG_AsVal_frag(double),"header") {
-SWIGINTERN int
-SWIG_AsVal_dec(double)(PyObject *obj, double *val)
-{
-  int res = SWIG_TypeError;
-  if (PyFloat_Check(obj)) {
-    if (val) *val = PyFloat_AsDouble(obj);
-    return SWIG_OK;
-  } else if (PyInt_Check(obj)) {
-    if (val) *val = PyInt_AsLong(obj);
-    return SWIG_OK;
-  } else if (PyLong_Check(obj)) {
-    double v = PyLong_AsDouble(obj);
-    if (!PyErr_Occurred()) {
-      if (val) *val = v;
-      return SWIG_OK;
-    } else {
-      PyErr_Clear();
-    }
-  }
-%#ifdef SWIG_PYTHON_CAST_MODE
-  {
-    int dispatch = 0;
-    double d = PyFloat_AsDouble(obj);
-    if (!PyErr_Occurred()) {
-      if (val) *val = d;
-      return SWIG_AddCast(SWIG_OK);
-    } else {
-      PyErr_Clear();
-    }
-    if (!dispatch) {
-      long v = PyLong_AsLong(obj);
-      if (!PyErr_Occurred()) {
-	if (val) *val = v;
-	return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
-      } else {
-	PyErr_Clear();
-      }
-    }
-  }
-%#endif
-  return res;
-}
-}
-
-
-
diff --git a/share/swig/2.0.11/python/pyrun.swg b/share/swig/2.0.11/python/pyrun.swg
deleted file mode 100644
index b077fad..0000000
--- a/share/swig/2.0.11/python/pyrun.swg
+++ /dev/null
@@ -1,1774 +0,0 @@
-/* -----------------------------------------------------------------------------
- * pyrun.swg
- *
- * This file contains the runtime support for Python modules
- * and includes code for managing global variables and pointer
- * type checking.
- *
- * ----------------------------------------------------------------------------- */
-
-/* Common SWIG API */
-
-/* for raw pointers */
-#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
-#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
-#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
-
-#ifdef SWIGPYTHON_BUILTIN
-#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(self, ptr, type, flags)
-#else
-#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
-#endif
-
-#define SWIG_InternalNewPointerObj(ptr, type, flags)	SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
-
-#define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
-#define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
-#define swig_owntype                                    int
-
-/* for raw packed data */
-#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
-#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
-
-/* for class or struct pointers */
-#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
-#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
-
-/* for C or C++ function pointers */
-#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
-#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
-
-/* for C++ member pointers, ie, member methods */
-#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
-#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
-
-
-/* Runtime API */
-
-#define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule(clientdata)
-#define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
-#define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)
-
-#define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
-#define SWIG_SetErrorMsg                        	SWIG_Python_SetErrorMsg				   
-#define SWIG_ErrorType(code)                    	SWIG_Python_ErrorType(code)                        
-#define SWIG_Error(code, msg)            		SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 
-#define SWIG_fail                        		goto fail					   
-
-
-/* Runtime API implementation */
-
-/* Error manipulation */
-
-SWIGINTERN void 
-SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
-  SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
-  PyErr_SetObject(errtype, obj);
-  Py_DECREF(obj);
-  SWIG_PYTHON_THREAD_END_BLOCK;
-}
-
-SWIGINTERN void 
-SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
-  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
-  PyErr_SetString(errtype, msg);
-  SWIG_PYTHON_THREAD_END_BLOCK;
-}
-
-#define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
-
-/* Set a constant value */
-
-#if defined(SWIGPYTHON_BUILTIN)
-
-SWIGINTERN void
-SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
-  PyObject *s = PyString_InternFromString(key);
-  PyList_Append(seq, s);
-  Py_DECREF(s);
-}
-
-SWIGINTERN void
-SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {   
-#if PY_VERSION_HEX < 0x02030000
-  PyDict_SetItemString(d, (char *)name, obj);
-#else
-  PyDict_SetItemString(d, name, obj);
-#endif
-  Py_DECREF(obj);
-  if (public_interface)
-    SwigPyBuiltin_AddPublicSymbol(public_interface, name);
-}
-
-#else
-
-SWIGINTERN void
-SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
-#if PY_VERSION_HEX < 0x02030000
-  PyDict_SetItemString(d, (char *)name, obj);
-#else
-  PyDict_SetItemString(d, name, obj);
-#endif
-  Py_DECREF(obj);                            
-}
-
-#endif
-
-/* Append a value to the result obj */
-
-SWIGINTERN PyObject*
-SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
-#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
-  if (!result) {
-    result = obj;
-  } else if (result == Py_None) {
-    Py_DECREF(result);
-    result = obj;
-  } else {
-    if (!PyList_Check(result)) {
-      PyObject *o2 = result;
-      result = PyList_New(1);
-      PyList_SetItem(result, 0, o2);
-    }
-    PyList_Append(result,obj);
-    Py_DECREF(obj);
-  }
-  return result;
-#else
-  PyObject*   o2;
-  PyObject*   o3;
-  if (!result) {
-    result = obj;
-  } else if (result == Py_None) {
-    Py_DECREF(result);
-    result = obj;
-  } else {
-    if (!PyTuple_Check(result)) {
-      o2 = result;
-      result = PyTuple_New(1);
-      PyTuple_SET_ITEM(result, 0, o2);
-    }
-    o3 = PyTuple_New(1);
-    PyTuple_SET_ITEM(o3, 0, obj);
-    o2 = result;
-    result = PySequence_Concat(o2, o3);
-    Py_DECREF(o2);
-    Py_DECREF(o3);
-  }
-  return result;
-#endif
-}
-
-/* Unpack the argument tuple */
-
-SWIGINTERN int
-SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
-{
-  if (!args) {
-    if (!min && !max) {
-      return 1;
-    } else {
-      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
-		   name, (min == max ? "" : "at least "), (int)min);
-      return 0;
-    }
-  }  
-  if (!PyTuple_Check(args)) {
-    if (min <= 1 && max >= 1) {
-      register int i;
-      objs[0] = args;
-      for (i = 1; i < max; ++i) {
-	objs[i] = 0;
-      }
-      return 2;
-    }
-    PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
-    return 0;
-  } else {
-    register Py_ssize_t l = PyTuple_GET_SIZE(args);
-    if (l < min) {
-      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
-		   name, (min == max ? "" : "at least "), (int)min, (int)l);
-      return 0;
-    } else if (l > max) {
-      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
-		   name, (min == max ? "" : "at most "), (int)max, (int)l);
-      return 0;
-    } else {
-      register int i;
-      for (i = 0; i < l; ++i) {
-	objs[i] = PyTuple_GET_ITEM(args, i);
-      }
-      for (; l < max; ++l) {
-	objs[l] = 0;
-      }
-      return i + 1;
-    }    
-  }
-}
-
-/* A functor is a function object with one single object argument */
-#if PY_VERSION_HEX >= 0x02020000
-#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunctionObjArgs(functor, obj, NULL);
-#else
-#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunction(functor, "O", obj);
-#endif
-
-/*
-  Helper for static pointer initialization for both C and C++ code, for example
-  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
-*/
-#ifdef __cplusplus
-#define SWIG_STATIC_POINTER(var)  var
-#else
-#define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
-#endif
-
-/* -----------------------------------------------------------------------------
- * Pointer declarations
- * ----------------------------------------------------------------------------- */
-
-/* Flags for new pointer objects */
-#define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
-#define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
-
-#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
-
-#define SWIG_BUILTIN_TP_INIT	    (SWIG_POINTER_OWN << 2)
-#define SWIG_BUILTIN_INIT	    (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*  How to access Py_None */
-#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
-#  ifndef SWIG_PYTHON_NO_BUILD_NONE
-#    ifndef SWIG_PYTHON_BUILD_NONE
-#      define SWIG_PYTHON_BUILD_NONE
-#    endif
-#  endif
-#endif
-
-#ifdef SWIG_PYTHON_BUILD_NONE
-#  ifdef Py_None
-#   undef Py_None
-#   define Py_None SWIG_Py_None()
-#  endif
-SWIGRUNTIMEINLINE PyObject * 
-_SWIG_Py_None(void)
-{
-  PyObject *none = Py_BuildValue((char*)"");
-  Py_DECREF(none);
-  return none;
-}
-SWIGRUNTIME PyObject * 
-SWIG_Py_None(void)
-{
-  static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
-  return none;
-}
-#endif
-
-/* The python void return value */
-
-SWIGRUNTIMEINLINE PyObject * 
-SWIG_Py_Void(void)
-{
-  PyObject *none = Py_None;
-  Py_INCREF(none);
-  return none;
-}
-
-/* SwigPyClientData */
-
-typedef struct {
-  PyObject *klass;
-  PyObject *newraw;
-  PyObject *newargs;
-  PyObject *destroy;
-  int delargs;
-  int implicitconv;
-  PyTypeObject *pytype;
-} SwigPyClientData;
-
-SWIGRUNTIMEINLINE int 
-SWIG_Python_CheckImplicit(swig_type_info *ty)
-{
-  SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
-  return data ? data->implicitconv : 0;
-}
-
-SWIGRUNTIMEINLINE PyObject *
-SWIG_Python_ExceptionType(swig_type_info *desc) {
-  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
-  PyObject *klass = data ? data->klass : 0;
-  return (klass ? klass : PyExc_RuntimeError);
-}
-
-
-SWIGRUNTIME SwigPyClientData * 
-SwigPyClientData_New(PyObject* obj)
-{
-  if (!obj) {
-    return 0;
-  } else {
-    SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
-    /* the klass element */
-    data->klass = obj;
-    Py_INCREF(data->klass);
-    /* the newraw method and newargs arguments used to create a new raw instance */
-    if (PyClass_Check(obj)) {
-      data->newraw = 0;
-      data->newargs = obj;
-      Py_INCREF(obj);
-    } else {
-#if (PY_VERSION_HEX < 0x02020000)
-      data->newraw = 0;
-#else
-      data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
-#endif
-      if (data->newraw) {
-	Py_INCREF(data->newraw);
-	data->newargs = PyTuple_New(1);
-	PyTuple_SetItem(data->newargs, 0, obj);
-      } else {
-	data->newargs = obj;
-      }
-      Py_INCREF(data->newargs);
-    }
-    /* the destroy method, aka as the C++ delete method */
-    data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
-    if (PyErr_Occurred()) {
-      PyErr_Clear();
-      data->destroy = 0;
-    }
-    if (data->destroy) {
-      int flags;
-      Py_INCREF(data->destroy);
-      flags = PyCFunction_GET_FLAGS(data->destroy);
-#ifdef METH_O
-      data->delargs = !(flags & (METH_O));
-#else
-      data->delargs = 0;
-#endif
-    } else {
-      data->delargs = 0;
-    }
-    data->implicitconv = 0;
-    data->pytype = 0;
-    return data;
-  }
-}
-
-SWIGRUNTIME void 
-SwigPyClientData_Del(SwigPyClientData *data) {
-  Py_XDECREF(data->newraw);
-  Py_XDECREF(data->newargs);
-  Py_XDECREF(data->destroy);
-}
-
-/* =============== SwigPyObject =====================*/
-
-typedef struct {
-  PyObject_HEAD
-  void *ptr;
-  swig_type_info *ty;
-  int own;
-  PyObject *next;
-#ifdef SWIGPYTHON_BUILTIN
-  PyObject *dict;
-#endif
-} SwigPyObject;
-
-SWIGRUNTIME PyObject *
-SwigPyObject_long(SwigPyObject *v)
-{
-  return PyLong_FromVoidPtr(v->ptr);
-}
-
-SWIGRUNTIME PyObject *
-SwigPyObject_format(const char* fmt, SwigPyObject *v)
-{
-  PyObject *res = NULL;
-  PyObject *args = PyTuple_New(1);
-  if (args) {
-    if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
-      PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
-      if (ofmt) {
-#if PY_VERSION_HEX >= 0x03000000
-	res = PyUnicode_Format(ofmt,args);
-#else
-	res = PyString_Format(ofmt,args);
-#endif
-	Py_DECREF(ofmt);
-      }
-      Py_DECREF(args);
-    }
-  }
-  return res;
-}
-
-SWIGRUNTIME PyObject *
-SwigPyObject_oct(SwigPyObject *v)
-{
-  return SwigPyObject_format("%o",v);
-}
-
-SWIGRUNTIME PyObject *
-SwigPyObject_hex(SwigPyObject *v)
-{
-  return SwigPyObject_format("%x",v);
-}
-
-SWIGRUNTIME PyObject *
-#ifdef METH_NOARGS
-SwigPyObject_repr(SwigPyObject *v)
-#else
-SwigPyObject_repr(SwigPyObject *v, PyObject *args)
-#endif
-{
-  const char *name = SWIG_TypePrettyName(v->ty);
-  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
-  if (v->next) {
-# ifdef METH_NOARGS
-    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
-# else
-    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
-# endif
-# if PY_VERSION_HEX >= 0x03000000
-    PyObject *joined = PyUnicode_Concat(repr, nrep);
-    Py_DecRef(repr);
-    Py_DecRef(nrep);
-    repr = joined;
-# else
-    PyString_ConcatAndDel(&repr,nrep);
-# endif
-  }
-  return repr;  
-}
-
-SWIGRUNTIME int
-SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
-{
-  void *i = v->ptr;
-  void *j = w->ptr;
-  return (i < j) ? -1 : ((i > j) ? 1 : 0);
-}
-
-/* Added for Python 3.x, would it also be useful for Python 2.x? */
-SWIGRUNTIME PyObject*
-SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
-{
-  PyObject* res;
-  if( op != Py_EQ && op != Py_NE ) {
-    Py_INCREF(Py_NotImplemented);
-    return Py_NotImplemented;
-  }
-  res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
-  return res;  
-}
-
-
-SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
-
-#ifdef SWIGPYTHON_BUILTIN
-static swig_type_info *SwigPyObject_stype = 0;
-SWIGRUNTIME PyTypeObject*
-SwigPyObject_type(void) {
-    SwigPyClientData *cd;
-    assert(SwigPyObject_stype);
-    cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
-    assert(cd);
-    assert(cd->pytype);
-    return cd->pytype;
-}
-#else
-SWIGRUNTIME PyTypeObject*
-SwigPyObject_type(void) {
-  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
-  return type;
-}
-#endif
-
-SWIGRUNTIMEINLINE int
-SwigPyObject_Check(PyObject *op) {
-#ifdef SWIGPYTHON_BUILTIN
-  PyTypeObject *target_tp = SwigPyObject_type();
-  if (PyType_IsSubtype(op->ob_type, target_tp))
-    return 1;
-  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
-#else
-  return (Py_TYPE(op) == SwigPyObject_type())
-    || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
-#endif
-}
-
-SWIGRUNTIME PyObject *
-SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
-
-SWIGRUNTIME void
-SwigPyObject_dealloc(PyObject *v)
-{
-  SwigPyObject *sobj = (SwigPyObject *) v;
-  PyObject *next = sobj->next;
-  if (sobj->own == SWIG_POINTER_OWN) {
-    swig_type_info *ty = sobj->ty;
-    SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
-    PyObject *destroy = data ? data->destroy : 0;
-    if (destroy) {
-      /* destroy is always a VARARGS method */
-      PyObject *res;
-      if (data->delargs) {
-	/* we need to create a temporary object to carry the destroy operation */
-	PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
-	res = SWIG_Python_CallFunctor(destroy, tmp);
-	Py_DECREF(tmp);
-      } else {
-	PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
-	PyObject *mself = PyCFunction_GET_SELF(destroy);
-	res = ((*meth)(mself, v));
-      }
-      Py_XDECREF(res);
-    } 
-#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
-    else {
-      const char *name = SWIG_TypePrettyName(ty);
-      printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
-    }
-#endif
-  } 
-  Py_XDECREF(next);
-  PyObject_DEL(v);
-}
-
-SWIGRUNTIME PyObject* 
-SwigPyObject_append(PyObject* v, PyObject* next)
-{
-  SwigPyObject *sobj = (SwigPyObject *) v;
-#ifndef METH_O
-  PyObject *tmp = 0;
-  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
-  next = tmp;
-#endif
-  if (!SwigPyObject_Check(next)) {
-    return NULL;
-  }
-  sobj->next = next;
-  Py_INCREF(next);
-  return SWIG_Py_Void();
-}
-
-SWIGRUNTIME PyObject* 
-#ifdef METH_NOARGS
-SwigPyObject_next(PyObject* v)
-#else
-SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
-#endif
-{
-  SwigPyObject *sobj = (SwigPyObject *) v;
-  if (sobj->next) {    
-    Py_INCREF(sobj->next);
-    return sobj->next;
-  } else {
-    return SWIG_Py_Void();
-  }
-}
-
-SWIGINTERN PyObject*
-#ifdef METH_NOARGS
-SwigPyObject_disown(PyObject *v)
-#else
-SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
-#endif
-{
-  SwigPyObject *sobj = (SwigPyObject *)v;
-  sobj->own = 0;
-  return SWIG_Py_Void();
-}
-
-SWIGINTERN PyObject*
-#ifdef METH_NOARGS
-SwigPyObject_acquire(PyObject *v)
-#else
-SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
-#endif
-{
-  SwigPyObject *sobj = (SwigPyObject *)v;
-  sobj->own = SWIG_POINTER_OWN;
-  return SWIG_Py_Void();
-}
-
-SWIGINTERN PyObject*
-SwigPyObject_own(PyObject *v, PyObject *args)
-{
-  PyObject *val = 0;
-#if (PY_VERSION_HEX < 0x02020000)
-  if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
-#elif (PY_VERSION_HEX < 0x02050000)
-  if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) 
-#else
-  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) 
-#endif
-    {
-      return NULL;
-    } 
-  else
-    {
-      SwigPyObject *sobj = (SwigPyObject *)v;
-      PyObject *obj = PyBool_FromLong(sobj->own);
-      if (val) {
-#ifdef METH_NOARGS
-	if (PyObject_IsTrue(val)) {
-	  SwigPyObject_acquire(v);
-	} else {
-	  SwigPyObject_disown(v);
-	}
-#else
-	if (PyObject_IsTrue(val)) {
-	  SwigPyObject_acquire(v,args);
-	} else {
-	  SwigPyObject_disown(v,args);
-	}
-#endif
-      } 
-      return obj;
-    }
-}
-
-#ifdef METH_O
-static PyMethodDef
-swigobject_methods[] = {
-  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
-  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"acquires ownership of the pointer"},
-  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
-  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)"appends another 'this' object"},
-  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
-  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
-  {0, 0, 0, 0}  
-};
-#else
-static PyMethodDef
-swigobject_methods[] = {
-  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
-  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
-  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
-  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
-  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
-  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
-  {0, 0, 0, 0}  
-};
-#endif
-
-#if PY_VERSION_HEX < 0x02020000
-SWIGINTERN PyObject *
-SwigPyObject_getattr(SwigPyObject *sobj,char *name)
-{
-  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
-}
-#endif
-
-SWIGRUNTIME PyTypeObject*
-SwigPyObject_TypeOnce(void) {
-  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
-
-  static PyNumberMethods SwigPyObject_as_number = {
-    (binaryfunc)0, /*nb_add*/
-    (binaryfunc)0, /*nb_subtract*/
-    (binaryfunc)0, /*nb_multiply*/
-    /* nb_divide removed in Python 3 */
-#if PY_VERSION_HEX < 0x03000000
-    (binaryfunc)0, /*nb_divide*/
-#endif
-    (binaryfunc)0, /*nb_remainder*/
-    (binaryfunc)0, /*nb_divmod*/
-    (ternaryfunc)0,/*nb_power*/
-    (unaryfunc)0,  /*nb_negative*/
-    (unaryfunc)0,  /*nb_positive*/
-    (unaryfunc)0,  /*nb_absolute*/
-    (inquiry)0,    /*nb_nonzero*/
-    0,		   /*nb_invert*/
-    0,		   /*nb_lshift*/
-    0,		   /*nb_rshift*/
-    0,		   /*nb_and*/
-    0,		   /*nb_xor*/
-    0,		   /*nb_or*/
-#if PY_VERSION_HEX < 0x03000000
-    0,   /*nb_coerce*/
-#endif
-    (unaryfunc)SwigPyObject_long, /*nb_int*/
-#if PY_VERSION_HEX < 0x03000000
-    (unaryfunc)SwigPyObject_long, /*nb_long*/
-#else
-    0, /*nb_reserved*/
-#endif
-    (unaryfunc)0,                 /*nb_float*/
-#if PY_VERSION_HEX < 0x03000000
-    (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
-    (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
-#endif
-#if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
-#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
-#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
-#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
-    0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
-#endif
-  };
-
-  static PyTypeObject swigpyobject_type;
-  static int type_init = 0;
-  if (!type_init) {
-    const PyTypeObject tmp = {
-      /* PyObject header changed in Python 3 */
-#if PY_VERSION_HEX >= 0x03000000
-      PyVarObject_HEAD_INIT(NULL, 0)
-#else
-      PyObject_HEAD_INIT(NULL)
-      0,                                    /* ob_size */
-#endif
-      (char *)"SwigPyObject",               /* tp_name */
-      sizeof(SwigPyObject),                 /* tp_basicsize */
-      0,                                    /* tp_itemsize */
-      (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
-      0,				    /* tp_print */
-#if PY_VERSION_HEX < 0x02020000
-      (getattrfunc)SwigPyObject_getattr,    /* tp_getattr */
-#else
-      (getattrfunc)0,                       /* tp_getattr */
-#endif
-      (setattrfunc)0,                       /* tp_setattr */
-#if PY_VERSION_HEX >= 0x03000000
-    0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
-#else
-      (cmpfunc)SwigPyObject_compare,        /* tp_compare */
-#endif
-      (reprfunc)SwigPyObject_repr,          /* tp_repr */
-      &SwigPyObject_as_number,              /* tp_as_number */
-      0,                                    /* tp_as_sequence */
-      0,                                    /* tp_as_mapping */
-      (hashfunc)0,                          /* tp_hash */
-      (ternaryfunc)0,                       /* tp_call */
-      0,				    /* tp_str */
-      PyObject_GenericGetAttr,              /* tp_getattro */
-      0,                                    /* tp_setattro */
-      0,                                    /* tp_as_buffer */
-      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
-      swigobject_doc,                       /* tp_doc */
-      0,                                    /* tp_traverse */
-      0,                                    /* tp_clear */
-      (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
-      0,                                    /* tp_weaklistoffset */
-#if PY_VERSION_HEX >= 0x02020000
-      0,                                    /* tp_iter */
-      0,                                    /* tp_iternext */
-      swigobject_methods,                   /* tp_methods */
-      0,                                    /* tp_members */
-      0,                                    /* tp_getset */
-      0,                                    /* tp_base */
-      0,                                    /* tp_dict */
-      0,                                    /* tp_descr_get */
-      0,                                    /* tp_descr_set */
-      0,                                    /* tp_dictoffset */
-      0,                                    /* tp_init */
-      0,                                    /* tp_alloc */
-      0,                                    /* tp_new */
-      0,                                    /* tp_free */
-      0,                                    /* tp_is_gc */
-      0,                                    /* tp_bases */
-      0,                                    /* tp_mro */
-      0,                                    /* tp_cache */
-      0,                                    /* tp_subclasses */
-      0,                                    /* tp_weaklist */
-#endif
-#if PY_VERSION_HEX >= 0x02030000
-      0,                                    /* tp_del */
-#endif
-#if PY_VERSION_HEX >= 0x02060000
-      0,                                    /* tp_version */
-#endif
-#ifdef COUNT_ALLOCS
-      0,0,0,0                               /* tp_alloc -> tp_next */
-#endif
-    };
-    swigpyobject_type = tmp;
-    type_init = 1;
-#if PY_VERSION_HEX < 0x02020000
-    swigpyobject_type.ob_type = &PyType_Type;
-#else
-    if (PyType_Ready(&swigpyobject_type) < 0)
-      return NULL;
-#endif
-  }
-  return &swigpyobject_type;
-}
-
-SWIGRUNTIME PyObject *
-SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
-{
-  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
-  if (sobj) {
-    sobj->ptr  = ptr;
-    sobj->ty   = ty;
-    sobj->own  = own;
-    sobj->next = 0;
-  }
-  return (PyObject *)sobj;
-}
-
-/* -----------------------------------------------------------------------------
- * Implements a simple Swig Packed type, and use it instead of string
- * ----------------------------------------------------------------------------- */
-
-typedef struct {
-  PyObject_HEAD
-  void *pack;
-  swig_type_info *ty;
-  size_t size;
-} SwigPyPacked;
-
-SWIGRUNTIME int
-SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
-{
-  char result[SWIG_BUFFER_SIZE];
-  fputs("<Swig Packed ", fp); 
-  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
-    fputs("at ", fp); 
-    fputs(result, fp); 
-  }
-  fputs(v->ty->name,fp); 
-  fputs(">", fp);
-  return 0; 
-}
-  
-SWIGRUNTIME PyObject *
-SwigPyPacked_repr(SwigPyPacked *v)
-{
-  char result[SWIG_BUFFER_SIZE];
-  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
-    return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
-  } else {
-    return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
-  }  
-}
-
-SWIGRUNTIME PyObject *
-SwigPyPacked_str(SwigPyPacked *v)
-{
-  char result[SWIG_BUFFER_SIZE];
-  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
-    return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
-  } else {
-    return SWIG_Python_str_FromChar(v->ty->name);
-  }  
-}
-
-SWIGRUNTIME int
-SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
-{
-  size_t i = v->size;
-  size_t j = w->size;
-  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
-  return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
-}
-
-SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
-
-SWIGRUNTIME PyTypeObject*
-SwigPyPacked_type(void) {
-  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
-  return type;
-}
-
-SWIGRUNTIMEINLINE int
-SwigPyPacked_Check(PyObject *op) {
-  return ((op)->ob_type == SwigPyPacked_TypeOnce()) 
-    || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
-}
-
-SWIGRUNTIME void
-SwigPyPacked_dealloc(PyObject *v)
-{
-  if (SwigPyPacked_Check(v)) {
-    SwigPyPacked *sobj = (SwigPyPacked *) v;
-    free(sobj->pack);
-  }
-  PyObject_DEL(v);
-}
-
-SWIGRUNTIME PyTypeObject*
-SwigPyPacked_TypeOnce(void) {
-  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
-  static PyTypeObject swigpypacked_type;
-  static int type_init = 0;
-  if (!type_init) {
-    const PyTypeObject tmp = {
-      /* PyObject header changed in Python 3 */
-#if PY_VERSION_HEX>=0x03000000
-      PyVarObject_HEAD_INIT(NULL, 0)
-#else
-      PyObject_HEAD_INIT(NULL)
-      0,                                    /* ob_size */
-#endif
-      (char *)"SwigPyPacked",               /* tp_name */
-      sizeof(SwigPyPacked),                 /* tp_basicsize */
-      0,                                    /* tp_itemsize */
-      (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
-      (printfunc)SwigPyPacked_print,        /* tp_print */
-      (getattrfunc)0,                       /* tp_getattr */
-      (setattrfunc)0,                       /* tp_setattr */
-#if PY_VERSION_HEX>=0x03000000
-      0, /* tp_reserved in 3.0.1 */
-#else
-      (cmpfunc)SwigPyPacked_compare,        /* tp_compare */
-#endif
-      (reprfunc)SwigPyPacked_repr,          /* tp_repr */
-      0,                                    /* tp_as_number */
-      0,                                    /* tp_as_sequence */
-      0,                                    /* tp_as_mapping */
-      (hashfunc)0,                          /* tp_hash */
-      (ternaryfunc)0,                       /* tp_call */
-      (reprfunc)SwigPyPacked_str,           /* tp_str */
-      PyObject_GenericGetAttr,              /* tp_getattro */
-      0,                                    /* tp_setattro */
-      0,                                    /* tp_as_buffer */
-      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
-      swigpacked_doc,                       /* tp_doc */
-      0,                                    /* tp_traverse */
-      0,                                    /* tp_clear */
-      0,                                    /* tp_richcompare */
-      0,                                    /* tp_weaklistoffset */
-#if PY_VERSION_HEX >= 0x02020000
-      0,                                    /* tp_iter */
-      0,                                    /* tp_iternext */
-      0,                                    /* tp_methods */
-      0,                                    /* tp_members */
-      0,                                    /* tp_getset */
-      0,                                    /* tp_base */
-      0,                                    /* tp_dict */
-      0,                                    /* tp_descr_get */
-      0,                                    /* tp_descr_set */
-      0,                                    /* tp_dictoffset */
-      0,                                    /* tp_init */
-      0,                                    /* tp_alloc */
-      0,                                    /* tp_new */
-      0,                                    /* tp_free */
-      0,                                    /* tp_is_gc */
-      0,                                    /* tp_bases */
-      0,                                    /* tp_mro */
-      0,                                    /* tp_cache */
-      0,                                    /* tp_subclasses */
-      0,                                    /* tp_weaklist */
-#endif
-#if PY_VERSION_HEX >= 0x02030000
-      0,                                    /* tp_del */
-#endif
-#if PY_VERSION_HEX >= 0x02060000
-      0,                                    /* tp_version */
-#endif
-#ifdef COUNT_ALLOCS
-      0,0,0,0                               /* tp_alloc -> tp_next */
-#endif
-    };
-    swigpypacked_type = tmp;
-    type_init = 1;
-#if PY_VERSION_HEX < 0x02020000
-    swigpypacked_type.ob_type = &PyType_Type;
-#else
-    if (PyType_Ready(&swigpypacked_type) < 0)
-      return NULL;
-#endif
-  }
-  return &swigpypacked_type;
-}
-
-SWIGRUNTIME PyObject *
-SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
-{
-  SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
-  if (sobj) {
-    void *pack = malloc(size);
-    if (pack) {
-      memcpy(pack, ptr, size);
-      sobj->pack = pack;
-      sobj->ty   = ty;
-      sobj->size = size;
-    } else {
-      PyObject_DEL((PyObject *) sobj);
-      sobj = 0;
-    }
-  }
-  return (PyObject *) sobj;
-}
-
-SWIGRUNTIME swig_type_info *
-SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
-{
-  if (SwigPyPacked_Check(obj)) {
-    SwigPyPacked *sobj = (SwigPyPacked *)obj;
-    if (sobj->size != size) return 0;
-    memcpy(ptr, sobj->pack, size);
-    return sobj->ty;
-  } else {
-    return 0;
-  }
-}
-
-/* -----------------------------------------------------------------------------
- * pointers/data manipulation
- * ----------------------------------------------------------------------------- */
-
-SWIGRUNTIMEINLINE PyObject *
-_SWIG_This(void)
-{
-    return SWIG_Python_str_FromChar("this");
-}
-
-static PyObject *swig_this = NULL;
-
-SWIGRUNTIME PyObject *
-SWIG_This(void)
-{
-  if (swig_this == NULL)
-    swig_this = _SWIG_This();
-  return swig_this;
-}
-
-/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
-
-/* TODO: I don't know how to implement the fast getset in Python 3 right now */
-#if PY_VERSION_HEX>=0x03000000
-#define SWIG_PYTHON_SLOW_GETSET_THIS 
-#endif
-
-SWIGRUNTIME SwigPyObject *
-SWIG_Python_GetSwigThis(PyObject *pyobj) 
-{
-  PyObject *obj;
-
-  if (SwigPyObject_Check(pyobj))
-    return (SwigPyObject *) pyobj;
-
-#ifdef SWIGPYTHON_BUILTIN
-  (void)obj;
-# ifdef PyWeakref_CheckProxy
-  if (PyWeakref_CheckProxy(pyobj)) {
-    pyobj = PyWeakref_GET_OBJECT(pyobj);
-    if (pyobj && SwigPyObject_Check(pyobj))
-      return (SwigPyObject*) pyobj;
-  }
-# endif
-  return NULL;
-#else
-
-  obj = 0;
-
-#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
-  if (PyInstance_Check(pyobj)) {
-    obj = _PyInstance_Lookup(pyobj, SWIG_This());      
-  } else {
-    PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
-    if (dictptr != NULL) {
-      PyObject *dict = *dictptr;
-      obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
-    } else {
-#ifdef PyWeakref_CheckProxy
-      if (PyWeakref_CheckProxy(pyobj)) {
-	PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
-	return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
-      }
-#endif
-      obj = PyObject_GetAttr(pyobj,SWIG_This());
-      if (obj) {
-	Py_DECREF(obj);
-      } else {
-	if (PyErr_Occurred()) PyErr_Clear();
-	return 0;
-      }
-    }
-  }
-#else
-  obj = PyObject_GetAttr(pyobj,SWIG_This());
-  if (obj) {
-    Py_DECREF(obj);
-  } else {
-    if (PyErr_Occurred()) PyErr_Clear();
-    return 0;
-  }
-#endif
-  if (obj && !SwigPyObject_Check(obj)) {
-    /* a PyObject is called 'this', try to get the 'real this'
-       SwigPyObject from it */ 
-    return SWIG_Python_GetSwigThis(obj);
-  }
-  return (SwigPyObject *)obj;
-#endif
-}
-
-/* Acquire a pointer value */
-
-SWIGRUNTIME int
-SWIG_Python_AcquirePtr(PyObject *obj, int own) {
-  if (own == SWIG_POINTER_OWN) {
-    SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
-    if (sobj) {
-      int oldown = sobj->own;
-      sobj->own = own;
-      return oldown;
-    }
-  }
-  return 0;
-}
-
-/* Convert a pointer value */
-
-SWIGRUNTIME int
-SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
-  int res;
-  SwigPyObject *sobj;
-  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
-
-  if (!obj)
-    return SWIG_ERROR;
-  if (obj == Py_None && !implicit_conv) {
-    if (ptr)
-      *ptr = 0;
-    return SWIG_OK;
-  }
-
-  res = SWIG_ERROR;
-
-  sobj = SWIG_Python_GetSwigThis(obj);
-  if (own)
-    *own = 0;
-  while (sobj) {
-    void *vptr = sobj->ptr;
-    if (ty) {
-      swig_type_info *to = sobj->ty;
-      if (to == ty) {
-        /* no type cast needed */
-        if (ptr) *ptr = vptr;
-        break;
-      } else {
-        swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
-        if (!tc) {
-          sobj = (SwigPyObject *)sobj->next;
-        } else {
-          if (ptr) {
-            int newmemory = 0;
-            *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
-            if (newmemory == SWIG_CAST_NEW_MEMORY) {
-              assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
-              if (own)
-                *own = *own | SWIG_CAST_NEW_MEMORY;
-            }
-          }
-          break;
-        }
-      }
-    } else {
-      if (ptr) *ptr = vptr;
-      break;
-    }
-  }
-  if (sobj) {
-    if (own)
-      *own = *own | sobj->own;
-    if (flags & SWIG_POINTER_DISOWN) {
-      sobj->own = 0;
-    }
-    res = SWIG_OK;
-  } else {
-    if (implicit_conv) {
-      SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
-      if (data && !data->implicitconv) {
-        PyObject *klass = data->klass;
-        if (klass) {
-          PyObject *impconv;
-          data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
-          impconv = SWIG_Python_CallFunctor(klass, obj);
-          data->implicitconv = 0;
-          if (PyErr_Occurred()) {
-            PyErr_Clear();
-            impconv = 0;
-          }
-          if (impconv) {
-            SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
-            if (iobj) {
-              void *vptr;
-              res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
-              if (SWIG_IsOK(res)) {
-                if (ptr) {
-                  *ptr = vptr;
-                  /* transfer the ownership to 'ptr' */
-                  iobj->own = 0;
-                  res = SWIG_AddCast(res);
-                  res = SWIG_AddNewMask(res);
-                } else {
-                  res = SWIG_AddCast(res);		    
-                }
-              }
-            }
-            Py_DECREF(impconv);
-          }
-        }
-      }
-    }
-    if (!SWIG_IsOK(res) && obj == Py_None) {
-      if (ptr)
-        *ptr = 0;
-      if (PyErr_Occurred())
-        PyErr_Clear();
-      res = SWIG_OK;
-    }
-  }
-  return res;
-}
-
-/* Convert a function ptr value */
-
-SWIGRUNTIME int
-SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
-  if (!PyCFunction_Check(obj)) {
-    return SWIG_ConvertPtr(obj, ptr, ty, 0);
-  } else {
-    void *vptr = 0;
-    
-    /* here we get the method pointer for callbacks */
-    const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
-    const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
-    if (desc)
-      desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
-    if (!desc) 
-      return SWIG_ERROR;
-    if (ty) {
-      swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
-      if (tc) {
-        int newmemory = 0;
-        *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
-        assert(!newmemory); /* newmemory handling not yet implemented */
-      } else {
-        return SWIG_ERROR;
-      }
-    } else {
-      *ptr = vptr;
-    }
-    return SWIG_OK;
-  }
-}
-
-/* Convert a packed value value */
-
-SWIGRUNTIME int
-SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
-  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
-  if (!to) return SWIG_ERROR;
-  if (ty) {
-    if (to != ty) {
-      /* check type cast? */
-      swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
-      if (!tc) return SWIG_ERROR;
-    }
-  }
-  return SWIG_OK;
-}  
-
-/* -----------------------------------------------------------------------------
- * Create a new pointer object
- * ----------------------------------------------------------------------------- */
-
-/*
-  Create a new instance object, without calling __init__, and set the
-  'this' attribute.
-*/
-
-SWIGRUNTIME PyObject* 
-SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
-{
-#if (PY_VERSION_HEX >= 0x02020000)
-  PyObject *inst = 0;
-  PyObject *newraw = data->newraw;
-  if (newraw) {
-    inst = PyObject_Call(newraw, data->newargs, NULL);
-    if (inst) {
-#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
-      PyObject **dictptr = _PyObject_GetDictPtr(inst);
-      if (dictptr != NULL) {
-	PyObject *dict = *dictptr;
-	if (dict == NULL) {
-	  dict = PyDict_New();
-	  *dictptr = dict;
-	  PyDict_SetItem(dict, SWIG_This(), swig_this);
-	}
-      }
-#else
-      PyObject *key = SWIG_This();
-      PyObject_SetAttr(inst, key, swig_this);
-#endif
-    }
-  } else {
-#if PY_VERSION_HEX >= 0x03000000
-    inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
-    if (inst) {
-      PyObject_SetAttr(inst, SWIG_This(), swig_this);
-      Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
-    }
-#else
-    PyObject *dict = PyDict_New();
-    if (dict) {
-      PyDict_SetItem(dict, SWIG_This(), swig_this);
-      inst = PyInstance_NewRaw(data->newargs, dict);
-      Py_DECREF(dict);
-    }
-#endif
-  }
-  return inst;
-#else
-#if (PY_VERSION_HEX >= 0x02010000)
-  PyObject *inst = 0;
-  PyObject *dict = PyDict_New();
-  if (dict) {
-    PyDict_SetItem(dict, SWIG_This(), swig_this);
-    inst = PyInstance_NewRaw(data->newargs, dict);
-    Py_DECREF(dict);
-  }
-  return (PyObject *) inst;
-#else
-  PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
-  if (inst == NULL) {
-    return NULL;
-  }
-  inst->in_class = (PyClassObject *)data->newargs;
-  Py_INCREF(inst->in_class);
-  inst->in_dict = PyDict_New();
-  if (inst->in_dict == NULL) {
-    Py_DECREF(inst);
-    return NULL;
-  }
-#ifdef Py_TPFLAGS_HAVE_WEAKREFS
-  inst->in_weakreflist = NULL;
-#endif
-#ifdef Py_TPFLAGS_GC
-  PyObject_GC_Init(inst);
-#endif
-  PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
-  return (PyObject *) inst;
-#endif
-#endif
-}
-
-SWIGRUNTIME void
-SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
-{
- PyObject *dict;
-#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
- PyObject **dictptr = _PyObject_GetDictPtr(inst);
- if (dictptr != NULL) {
-   dict = *dictptr;
-   if (dict == NULL) {
-     dict = PyDict_New();
-     *dictptr = dict;
-   }
-   PyDict_SetItem(dict, SWIG_This(), swig_this);
-   return;
- }
-#endif
- dict = PyObject_GetAttrString(inst, (char*)"__dict__");
- PyDict_SetItem(dict, SWIG_This(), swig_this);
- Py_DECREF(dict);
-} 
-
-
-SWIGINTERN PyObject *
-SWIG_Python_InitShadowInstance(PyObject *args) {
-  PyObject *obj[2];
-  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
-    return NULL;
-  } else {
-    SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
-    if (sthis) {
-      SwigPyObject_append((PyObject*) sthis, obj[1]);
-    } else {
-      SWIG_Python_SetSwigThis(obj[0], obj[1]);
-    }
-    return SWIG_Py_Void();
-  }
-}
-
-/* Create a new pointer object */
-
-SWIGRUNTIME PyObject *
-SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
-  SwigPyClientData *clientdata;
-  PyObject * robj;
-  int own;
-
-  if (!ptr)
-    return SWIG_Py_Void();
-
-  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
-  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
-  if (clientdata && clientdata->pytype) {
-    SwigPyObject *newobj;
-    if (flags & SWIG_BUILTIN_TP_INIT) {
-      newobj = (SwigPyObject*) self;
-      if (newobj->ptr) {
-        PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
-        while (newobj->next)
-	  newobj = (SwigPyObject *) newobj->next;
-        newobj->next = next_self;
-        newobj = (SwigPyObject *)next_self;
-      }
-    } else {
-      newobj = PyObject_New(SwigPyObject, clientdata->pytype);
-    }
-    if (newobj) {
-      newobj->ptr = ptr;
-      newobj->ty = type;
-      newobj->own = own;
-      newobj->next = 0;
-#ifdef SWIGPYTHON_BUILTIN
-      newobj->dict = 0;
-#endif
-      return (PyObject*) newobj;
-    }
-    return SWIG_Py_Void();
-  }
-
-  assert(!(flags & SWIG_BUILTIN_TP_INIT));
-
-  robj = SwigPyObject_New(ptr, type, own);
-  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
-    PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
-    Py_DECREF(robj);
-    robj = inst;
-  }
-  return robj;
-}
-
-/* Create a new packed object */
-
-SWIGRUNTIMEINLINE PyObject *
-SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
-  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
-}
-
-/* -----------------------------------------------------------------------------*
- *  Get type list 
- * -----------------------------------------------------------------------------*/
-
-#ifdef SWIG_LINK_RUNTIME
-void *SWIG_ReturnGlobalTypeList(void *);
-#endif
-
-SWIGRUNTIME swig_module_info *
-SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
-  static void *type_pointer = (void *)0;
-  /* first check if module already created */
-  if (!type_pointer) {
-#ifdef SWIG_LINK_RUNTIME
-    type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
-#else
-# ifdef SWIGPY_USE_CAPSULE
-    type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
-# else
-    type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
-				    (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
-# endif
-    if (PyErr_Occurred()) {
-      PyErr_Clear();
-      type_pointer = (void *)0;
-    }
-#endif
-  }
-  return (swig_module_info *) type_pointer;
-}
-
-#if PY_MAJOR_VERSION < 2
-/* PyModule_AddObject function was introduced in Python 2.0.  The following function
-   is copied out of Python/modsupport.c in python version 2.3.4 */
-SWIGINTERN int
-PyModule_AddObject(PyObject *m, char *name, PyObject *o)
-{
-  PyObject *dict;
-  if (!PyModule_Check(m)) {
-    PyErr_SetString(PyExc_TypeError,
-		    "PyModule_AddObject() needs module as first arg");
-    return SWIG_ERROR;
-  }
-  if (!o) {
-    PyErr_SetString(PyExc_TypeError,
-		    "PyModule_AddObject() needs non-NULL value");
-    return SWIG_ERROR;
-  }
-  
-  dict = PyModule_GetDict(m);
-  if (dict == NULL) {
-    /* Internal error -- modules must have a dict! */
-    PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
-		 PyModule_GetName(m));
-    return SWIG_ERROR;
-  }
-  if (PyDict_SetItemString(dict, name, o))
-    return SWIG_ERROR;
-  Py_DECREF(o);
-  return SWIG_OK;
-}
-#endif
-
-SWIGRUNTIME void
-#ifdef SWIGPY_USE_CAPSULE
-SWIG_Python_DestroyModule(PyObject *obj)
-#else
-SWIG_Python_DestroyModule(void *vptr)
-#endif
-{
-#ifdef SWIGPY_USE_CAPSULE
-  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
-#else
-  swig_module_info *swig_module = (swig_module_info *) vptr;
-#endif
-  swig_type_info **types = swig_module->types;
-  size_t i;
-  for (i =0; i < swig_module->size; ++i) {
-    swig_type_info *ty = types[i];
-    if (ty->owndata) {
-      SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
-      if (data) SwigPyClientData_Del(data);
-    }
-  }
-  Py_DECREF(SWIG_This());
-  swig_this = NULL;
-}
-
-SWIGRUNTIME void
-SWIG_Python_SetModule(swig_module_info *swig_module) {
-#if PY_VERSION_HEX >= 0x03000000
- /* Add a dummy module object into sys.modules */
-  PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
-#else
-  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
-  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
-#endif
-#ifdef SWIGPY_USE_CAPSULE
-  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
-  if (pointer && module) {
-    PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
-  } else {
-    Py_XDECREF(pointer);
-  }
-#else
-  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
-  if (pointer && module) {
-    PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
-  } else {
-    Py_XDECREF(pointer);
-  }
-#endif
-}
-
-/* The python cached type query */
-SWIGRUNTIME PyObject *
-SWIG_Python_TypeCache(void) {
-  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
-  return cache;
-}
-
-SWIGRUNTIME swig_type_info *
-SWIG_Python_TypeQuery(const char *type)
-{
-  PyObject *cache = SWIG_Python_TypeCache();
-  PyObject *key = SWIG_Python_str_FromChar(type); 
-  PyObject *obj = PyDict_GetItem(cache, key);
-  swig_type_info *descriptor;
-  if (obj) {
-#ifdef SWIGPY_USE_CAPSULE
-    descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
-#else
-    descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
-#endif
-  } else {
-    swig_module_info *swig_module = SWIG_GetModule(0);
-    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
-    if (descriptor) {
-#ifdef SWIGPY_USE_CAPSULE
-      obj = PyCapsule_New((void*) descriptor, NULL, NULL);
-#else
-      obj = PyCObject_FromVoidPtr(descriptor, NULL);
-#endif
-      PyDict_SetItem(cache, key, obj);
-      Py_DECREF(obj);
-    }
-  }
-  Py_DECREF(key);
-  return descriptor;
-}
-
-/* 
-   For backward compatibility only
-*/
-#define SWIG_POINTER_EXCEPTION  0
-#define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
-#define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
-
-SWIGRUNTIME int
-SWIG_Python_AddErrMesg(const char* mesg, int infront)
-{  
-  if (PyErr_Occurred()) {
-    PyObject *type = 0;
-    PyObject *value = 0;
-    PyObject *traceback = 0;
-    PyErr_Fetch(&type, &value, &traceback);
-    if (value) {
-      char *tmp;
-      PyObject *old_str = PyObject_Str(value);
-      Py_XINCREF(type);
-      PyErr_Clear();
-      if (infront) {
-	PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
-      } else {
-	PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
-      }
-      SWIG_Python_str_DelForPy3(tmp);
-      Py_DECREF(old_str);
-    }
-    return 1;
-  } else {
-    return 0;
-  }
-}
-  
-SWIGRUNTIME int
-SWIG_Python_ArgFail(int argnum)
-{
-  if (PyErr_Occurred()) {
-    /* add information about failing argument */
-    char mesg[256];
-    PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
-    return SWIG_Python_AddErrMesg(mesg, 1);
-  } else {
-    return 0;
-  }
-}
-
-SWIGRUNTIMEINLINE const char *
-SwigPyObject_GetDesc(PyObject *self)
-{
-  SwigPyObject *v = (SwigPyObject *)self;
-  swig_type_info *ty = v ? v->ty : 0;
-  return ty ? ty->str : "";
-}
-
-SWIGRUNTIME void
-SWIG_Python_TypeError(const char *type, PyObject *obj)
-{
-  if (type) {
-#if defined(SWIG_COBJECT_TYPES)
-    if (obj && SwigPyObject_Check(obj)) {
-      const char *otype = (const char *) SwigPyObject_GetDesc(obj);
-      if (otype) {
-	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
-		     type, otype);
-	return;
-      }
-    } else 
-#endif      
-    {
-      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
-      if (otype) {
-	PyObject *str = PyObject_Str(obj);
-	const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
-	if (cstr) {
-	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
-		       type, otype, cstr);
-          SWIG_Python_str_DelForPy3(cstr);
-	} else {
-	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
-		       type, otype);
-	}
-	Py_XDECREF(str);
-	return;
-      }
-    }   
-    PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
-  } else {
-    PyErr_Format(PyExc_TypeError, "unexpected type is received");
-  }
-}
-
-
-/* Convert a pointer value, signal an exception on a type mismatch */
-SWIGRUNTIME void *
-SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
-  void *result;
-  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
-    PyErr_Clear();
-#if SWIG_POINTER_EXCEPTION
-    if (flags) {
-      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
-      SWIG_Python_ArgFail(argnum);
-    }
-#endif
-  }
-  return result;
-}
-
-#ifdef SWIGPYTHON_BUILTIN
-SWIGRUNTIME int
-SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
-  PyTypeObject *tp = obj->ob_type;
-  PyObject *descr;
-  PyObject *encoded_name;
-  descrsetfunc f;
-  int res = -1;
-
-# ifdef Py_USING_UNICODE
-  if (PyString_Check(name)) {
-    name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
-    if (!name)
-      return -1;
-  } else if (!PyUnicode_Check(name))
-# else
-  if (!PyString_Check(name))
-# endif
-  {
-    PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
-    return -1;
-  } else {
-    Py_INCREF(name);
-  }
-
-  if (!tp->tp_dict) {
-    if (PyType_Ready(tp) < 0)
-      goto done;
-  }
-
-  descr = _PyType_Lookup(tp, name);
-  f = NULL;
-  if (descr != NULL)
-    f = descr->ob_type->tp_descr_set;
-  if (!f) {
-    if (PyString_Check(name)) {
-      encoded_name = name;
-      Py_INCREF(name);
-    } else {
-      encoded_name = PyUnicode_AsUTF8String(name);
-    }
-    PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
-    Py_DECREF(encoded_name);
-  } else {
-    res = f(descr, obj, value);
-  }
-  
-  done:
-  Py_DECREF(name);
-  return res;
-}
-#endif
-
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/share/swig/2.0.11/python/pystdcommon.swg b/share/swig/2.0.11/python/pystdcommon.swg
deleted file mode 100644
index 2f223a8..0000000
--- a/share/swig/2.0.11/python/pystdcommon.swg
+++ /dev/null
@@ -1,259 +0,0 @@
-%fragment("StdTraits","header",fragment="StdTraitsCommon")
-{
-namespace swig {  
-  /*
-    Traits that provides the from method
-  */
-  template <class Type> struct traits_from_ptr {
-    static PyObject *from(Type *val, int owner = 0) {
-      return SWIG_InternalNewPointerObj(val, type_info<Type>(), owner);
-    }
-  };
-
-  template <class Type> struct traits_from {
-    static PyObject *from(const Type& val) {
-      return traits_from_ptr<Type>::from(new Type(val), 1);
-    }
-  };
-
-  template <class Type> struct traits_from<Type *> {
-    static PyObject *from(Type* val) {
-      return traits_from_ptr<Type>::from(val, 0);
-    }
-  };
-
-  template <class Type> struct traits_from<const Type *> {
-    static PyObject *from(const Type* val) {
-      return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
-    }
-  };
-
-
-  template <class Type>
-  inline PyObject *from(const Type& val) {
-    return traits_from<Type>::from(val);
-  }
-
-  template <class Type>
-  inline PyObject *from_ptr(Type* val, int owner) {
-    return traits_from_ptr<Type>::from(val, owner);
-  }
-
-  /*
-    Traits that provides the asval/as/check method
-  */
-  template <class Type>
-  struct traits_asptr {   
-    static int asptr(PyObject *obj, Type **val) {
-      Type *p;
-      int res = SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0);
-      if (SWIG_IsOK(res)) {
-	if (val) *val = p;
-      }
-      return res;
-    }
-  }; 
-
-  template <class Type>
-  inline int asptr(PyObject *obj, Type **vptr) {
-    return traits_asptr<Type>::asptr(obj, vptr);
-  }
-
-  template <class Type> 
-  struct traits_asval {
-    static int asval(PyObject *obj, Type *val) {
-      if (val) {
-	Type *p = 0;
-	int res = traits_asptr<Type>::asptr(obj, &p);
-	if (!SWIG_IsOK(res)) return res;	
-	if (p) {
-	  typedef typename noconst_traits<Type>::noconst_type noconst_type;
-	  *(const_cast<noconst_type*>(val)) = *p;
-	  if (SWIG_IsNewObj(res)){
-	    %delete(p);
-	    res = SWIG_DelNewMask(res);
-	  }
-	  return res;
-	} else {
-	  return SWIG_ERROR;
-	}
-      } else {
-	return traits_asptr<Type>::asptr(obj, (Type **)(0));
-      }
-    }
-  };
-
-  template <class Type> struct traits_asval<Type*> {
-    static int asval(PyObject *obj, Type **val) {
-      if (val) {
-        typedef typename noconst_traits<Type>::noconst_type noconst_type;
-        noconst_type *p = 0;
-        int res = traits_asptr<noconst_type>::asptr(obj,  &p);
-        if (SWIG_IsOK(res)) {
-          *(const_cast<noconst_type**>(val)) = p;
-	}
-	return res;
-      } else {
-	return traits_asptr<Type>::asptr(obj, (Type **)(0));
-      }
-    }
-  };
-  
-  template <class Type>
-  inline int asval(PyObject *obj, Type *val) {
-    return traits_asval<Type>::asval(obj, val);
-  }
-
-  template <class Type> 
-  struct traits_as<Type, value_category> {
-    static Type as(PyObject *obj, bool throw_error) {
-      Type v;
-      int res = asval(obj, &v);
-      if (!obj || !SWIG_IsOK(res)) {
-	if (!PyErr_Occurred()) {
-	  ::%type_error(swig::type_name<Type>());
-	}
-	if (throw_error) throw std::invalid_argument("bad type");
-      }
-      return v;
-    }
-  };
-
-  template <class Type> 
-  struct traits_as<Type, pointer_category> {
-    static Type as(PyObject *obj, bool throw_error) {
-      Type *v = 0;      
-      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
-      if (SWIG_IsOK(res) && v) {
-	if (SWIG_IsNewObj(res)) {
-	  Type r(*v);
-	  %delete(v);
-	  return r;
-	} else {
-	  return *v;
-	}
-      } else {
-	// Uninitialized return value, no Type() constructor required.
-	static Type *v_def = (Type*) malloc(sizeof(Type));
-	if (!PyErr_Occurred()) {
-	  %type_error(swig::type_name<Type>());
-	}
-	if (throw_error) throw std::invalid_argument("bad type");
-	memset(v_def,0,sizeof(Type));
-	return *v_def;
-      }
-    }
-  };
-
-  template <class Type> 
-  struct traits_as<Type*, pointer_category> {
-    static Type* as(PyObject *obj, bool throw_error) {
-      Type *v = 0;      
-      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
-      if (SWIG_IsOK(res)) {
-	return v;
-      } else {
-	if (!PyErr_Occurred()) {
-	  %type_error(swig::type_name<Type>());
-	}
-	if (throw_error) throw std::invalid_argument("bad type");
-	return 0;
-      }
-    }
-  };
-    
-  template <class Type>
-  inline Type as(PyObject *obj, bool te = false) {
-    return traits_as<Type, typename traits<Type>::category>::as(obj, te);
-  }
-
-  template <class Type> 
-  struct traits_check<Type, value_category> {
-    static bool check(PyObject *obj) {
-      int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
-      return SWIG_IsOK(res) ? true : false;
-    }
-  };
-
-  template <class Type> 
-  struct traits_check<Type, pointer_category> {
-    static bool check(PyObject *obj) {
-      int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
-      return SWIG_IsOK(res) ? true : false;
-    }
-  };
-
-  template <class Type>
-  inline bool check(PyObject *obj) {
-    return traits_check<Type, typename traits<Type>::category>::check(obj);
-  }
-}
-}
-
-//
-// Backward compatibility
-//
-
-#ifdef SWIG_PYTHON_BACKWARD_COMP
-%{
-#include <string>
-                                                                              
-PyObject* SwigInt_FromBool(bool b) {
-    return PyInt_FromLong(b ? 1L : 0L);
-}
-double SwigNumber_Check(PyObject* o) {
-    return PyFloat_Check(o) || PyInt_Check(o) || PyLong_Check(o);
-}
-double SwigNumber_AsDouble(PyObject* o) {
-    return PyFloat_Check(o) ? PyFloat_AsDouble(o)
-        : (PyInt_Check(o) ?   double(PyInt_AsLong(o))
-                            : double(PyLong_AsLong(o)));
-}
-PyObject* SwigString_FromString(const std::string& s) {
-    return PyString_FromStringAndSize(s.data(),s.size());
-}
-std::string SwigString_AsString(PyObject* o) {
-    return std::string(PyString_AsString(o));
-}
-%}
-
-#endif
-
-
-%define %specialize_std_container(Type,Check,As,From)
-%{
-namespace swig {
-  template <>  struct traits_asval<Type > {   
-    typedef Type value_type;
-    static int asval(PyObject *obj, value_type *val) {
-      if (Check(obj)) {
-	if (val) *val = As(obj);
-	return SWIG_OK;
-      }
-      return SWIG_ERROR;
-    }
-  };
-  template <>  struct traits_from<Type > {
-    typedef Type value_type;
-    static PyObject *from(const value_type& val) {
-      return From(val);
-    }
-  };
-
-  template <> 
-  struct traits_check<Type, value_category> {
-    static int check(PyObject *obj) {
-      int res = Check(obj);
-      return obj && res ? res : 0;
-    }
-  };
-}
-%}
-%enddef
-
-
-#define specialize_std_vector(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
-#define specialize_std_list(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
-#define specialize_std_deque(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
-#define specialize_std_set(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
-#define specialize_std_multiset(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
diff --git a/share/swig/2.0.11/python/pystrings.swg b/share/swig/2.0.11/python/pystrings.swg
deleted file mode 100644
index f6a4eba..0000000
--- a/share/swig/2.0.11/python/pystrings.swg
+++ /dev/null
@@ -1,103 +0,0 @@
-/* ------------------------------------------------------------
- *  utility methods for char strings 
- * ------------------------------------------------------------ */
-%fragment("SWIG_AsCharPtrAndSize","header",fragment="SWIG_pchar_descriptor") {
-SWIGINTERN int
-SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
-{
-%#if PY_VERSION_HEX>=0x03000000
-  if (PyUnicode_Check(obj))
-%#else  
-  if (PyString_Check(obj))
-%#endif
-  {
-    char *cstr; Py_ssize_t len;
-%#if PY_VERSION_HEX>=0x03000000
-    if (!alloc && cptr) {
-        /* We can't allow converting without allocation, since the internal
-           representation of string in Python 3 is UCS-2/UCS-4 but we require
-           a UTF-8 representation.
-           TODO(bhy) More detailed explanation */
-        return SWIG_RuntimeError;
-    }
-    obj = PyUnicode_AsUTF8String(obj);
-    PyBytes_AsStringAndSize(obj, &cstr, &len);
-    if(alloc) *alloc = SWIG_NEWOBJ;
-%#else
-    PyString_AsStringAndSize(obj, &cstr, &len);
-%#endif
-    if (cptr) {
-      if (alloc) {
-	/* 
-	   In python the user should not be able to modify the inner
-	   string representation. To warranty that, if you define
-	   SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
-	   buffer is always returned.
-
-	   The default behavior is just to return the pointer value,
-	   so, be careful.
-	*/ 
-%#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
-	if (*alloc != SWIG_OLDOBJ) 
-%#else
-	if (*alloc == SWIG_NEWOBJ) 
-%#endif
-	  {
-	    *cptr = %new_copy_array(cstr, len + 1, char);
-	    *alloc = SWIG_NEWOBJ;
-	  }
-	else {
-	  *cptr = cstr;
-	  *alloc = SWIG_OLDOBJ;
-	}
-      } else {
-        %#if PY_VERSION_HEX>=0x03000000
-        assert(0); /* Should never reach here in Python 3 */
-        %#endif
-	*cptr = SWIG_Python_str_AsChar(obj);
-      }
-    }
-    if (psize) *psize = len + 1;
-%#if PY_VERSION_HEX>=0x03000000
-    Py_XDECREF(obj);
-%#endif
-    return SWIG_OK;
-  } else {
-    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
-    if (pchar_descriptor) {
-      void* vptr = 0;
-      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
-	if (cptr) *cptr = (char *) vptr;
-	if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
-	if (alloc) *alloc = SWIG_OLDOBJ;
-	return SWIG_OK;
-      }
-    }
-  }
-  return SWIG_TypeError;
-}
-}
-
-%fragment("SWIG_FromCharPtrAndSize","header",fragment="SWIG_pchar_descriptor") {
-SWIGINTERNINLINE PyObject *
-SWIG_FromCharPtrAndSize(const char* carray, size_t size)
-{
-  if (carray) {
-    if (size > INT_MAX) {
-      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
-      return pchar_descriptor ? 
-	SWIG_InternalNewPointerObj(%const_cast(carray,char *), pchar_descriptor, 0) : SWIG_Py_Void();
-    } else {
-%#if PY_VERSION_HEX >= 0x03000000
-      return PyUnicode_FromStringAndSize(carray, %numeric_cast(size,int));
-%#else
-      return PyString_FromStringAndSize(carray, %numeric_cast(size,int));
-%#endif
-    }
-  } else {
-    return SWIG_Py_Void();
-  }
-}
-}
-
-
diff --git a/share/swig/2.0.11/python/pythonkw.swg b/share/swig/2.0.11/python/pythonkw.swg
deleted file mode 100644
index 8ad0ef1..0000000
--- a/share/swig/2.0.11/python/pythonkw.swg
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
-  Warnings for Python keywords, built-in names and bad names.
-*/
-
-#define PYTHONKW(x) %keywordwarn("'" `x` "' is a python keyword, renaming to '_" `x` "'", rename="_%s")  `x`
-#define PYTHONBN(x) %builtinwarn("'" `x` "' conflicts with a built-in name in python")  `x`
-
-
-/*
-  Warnings for Python keywords 
-  http://www.fnorb.org/docs/1.2/Fnorb-Guide/node62.html
-*/
-
-PYTHONKW(and);
-PYTHONKW(assert);
-PYTHONKW(break);
-PYTHONKW(class);
-PYTHONKW(continue);
-PYTHONKW(def);
-PYTHONKW(del);
-PYTHONKW(elif);
-PYTHONKW(else);
-PYTHONKW(except);
-PYTHONKW(exec);
-PYTHONKW(finally);
-PYTHONKW(for);
-PYTHONKW(from);
-PYTHONKW(global);
-PYTHONKW(if);
-PYTHONKW(import);
-PYTHONKW(in);
-PYTHONKW(is);
-PYTHONKW(lambda);
-PYTHONKW(not);
-PYTHONKW(or);
-PYTHONKW(pass);
-PYTHONKW(print);
-PYTHONKW(raise);
-PYTHONKW(return);
-PYTHONKW(try);
-PYTHONKW(while);
-PYTHONKW(yield);
-
-/*
-  built-in functions
-  http://www.zvon.org/other/python/doc21/lib/built-in-funcs.html
- */ 
-
-PYTHONBN(abs);
-PYTHONBN(apply);
-PYTHONBN(bool);
-PYTHONBN(buffer);
-PYTHONBN(callable);
-PYTHONBN(chr);
-PYTHONBN(classmethod);
-PYTHONBN(cmp);
-PYTHONBN(coerce);
-PYTHONBN(compile);
-PYTHONBN(complex);
-PYTHONBN(delattr);
-PYTHONBN(dict);
-PYTHONBN(dir);
-PYTHONBN(divmod);
-PYTHONBN(enumerate);
-PYTHONBN(eval);
-PYTHONBN(execfile);
-PYTHONBN(file);
-PYTHONBN(filter);
-PYTHONBN(float);
-PYTHONBN(frozenset);
-PYTHONBN(getattr);
-PYTHONBN(globals);
-PYTHONBN(hasattr);
-PYTHONBN(hash);
-PYTHONBN(hex);
-PYTHONBN(id);
-PYTHONBN(input);
-PYTHONBN(int);
-PYTHONBN(intern);
-PYTHONBN(isinstance);
-PYTHONBN(issubclass);
-PYTHONBN(iter);
-PYTHONBN(len);
-PYTHONBN(list);
-PYTHONBN(locals);
-PYTHONBN(long);
-PYTHONBN(map);
-PYTHONBN(max);
-PYTHONBN(min);
-PYTHONBN(object);
-PYTHONBN(oct);
-PYTHONBN(open);
-PYTHONBN(ord);
-PYTHONBN(pow);
-PYTHONBN(property);
-PYTHONBN(range);
-PYTHONBN(raw_input);
-PYTHONBN(reduce);
-PYTHONBN(reload);
-PYTHONBN(repr);
-PYTHONBN(reversed);
-PYTHONBN(round);
-PYTHONBN(set);
-PYTHONBN(setattr);
-PYTHONBN(slice);
-PYTHONBN(sorted);
-PYTHONBN(staticmethod);
-PYTHONBN(str);
-PYTHONBN(sum);
-PYTHONBN(super);
-PYTHONBN(tuple);
-PYTHONBN(type);
-PYTHONBN(unichr);
-PYTHONBN(unicode);
-PYTHONBN(vars);
-PYTHONBN(xrange);
-PYTHONBN(zip);
-
-
-/* 
-   built-in names
-   boolean type and None
-*/
-PYTHONBN(True);
-PYTHONBN(False);
-
-PYTHONKW(None);
-
-
-/* 
-   'self' is also a bad Name
-*/
-PYTHONBN(self);
-
-#undef PYTHONBN
-#undef PYTHONKW
diff --git a/share/swig/2.0.11/python/pytypemaps.swg b/share/swig/2.0.11/python/pytypemaps.swg
deleted file mode 100644
index c64b47b..0000000
--- a/share/swig/2.0.11/python/pytypemaps.swg
+++ /dev/null
@@ -1,101 +0,0 @@
-/* ------------------------------------------------------------
- *  Typemap specializations for Python
- * ------------------------------------------------------------ */
-
-/* ------------------------------------------------------------
- *  Fragment section
- * ------------------------------------------------------------ */
-/* bool is dangerous in Python, change precedence */
-#undef SWIG_TYPECHECK_BOOL
-%define SWIG_TYPECHECK_BOOL             10000 %enddef
-
-/* Include fundamental fragemt definitions */
-%include <typemaps/fragments.swg>
-
-/* Look for user fragments file. */
-%include <pyfragments.swg>
-
-/* Python fragments for fundamental types */
-%include <pyprimtypes.swg>
-
-/* Python fragments for char* strings */
-%include <pystrings.swg>
-
-/* Backward compatibility output helper */
-%fragment("t_output_helper","header") %{
-#define t_output_helper SWIG_Python_AppendOutput
-%}
-
-
-/* ------------------------------------------------------------
- *  Unified typemap section
- * ------------------------------------------------------------ */
-
-/* directors are supported in Python */
-#ifndef SWIG_DIRECTOR_TYPEMAPS
-#define SWIG_DIRECTOR_TYPEMAPS
-#endif
-
-
-/* Python types */
-#define SWIG_Object                     PyObject *
-#define VOID_Object                     SWIG_Py_Void()
-
-/* Python allows implicit conversion */
-#define %implicitconv_flag              $implicitconv 
-
-
-/* Overload of the output/constant/exception/dirout handling */
-
-/* append output */
-#define SWIG_AppendOutput(result, obj)  SWIG_Python_AppendOutput(result, obj)
-
-/* set constant */
-#if defined(SWIGPYTHON_BUILTIN)
-#define SWIG_SetConstant(name, obj) SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, name,obj) 
-#else
-#define SWIG_SetConstant(name, obj) SWIG_Python_SetConstant(d, name,obj) 
-#endif
-
-/* raise */
-#define SWIG_Raise(obj, type, desc)     SWIG_Python_Raise(obj, type, desc)
-
-/* Include the unified typemap library */
-%include <typemaps/swigtypemaps.swg>
-
-
-/*  ------------------------------------------------------------
- *  Python extra typemaps / typemap overrides
- * ------------------------------------------------------------ */
-
-/* Get the address of the 'python self' object */
-
-%typemap(in,numinputs=0,noblock=1) PyObject **PYTHON_SELF {
-  $1 = &$self;
-}
-
-
-/* Consttab, needed for callbacks, it should be removed later */
-
-%typemap(consttab) SWIGTYPE ((*)(ANY))  
-{ SWIG_PY_POINTER, (char*)"$symname", 0, 0, (void *)($value), &$descriptor }
-
-%typemap(constcode) SWIGTYPE ((*)(ANY)) "";
-
-
-/* Smart Pointers */
-%typemap(out,noblock=1) const SWIGTYPE & SMARTPOINTER  {
-  $result = SWIG_NewPointerObj(%new_copy(*$1, $*ltype), $descriptor, SWIG_POINTER_OWN | %newpointer_flags);
-}
-
-%typemap(ret,noblock=1) const SWIGTYPE & SMARTPOINTER, SWIGTYPE SMARTPOINTER {
-  if ($result) {
-    PyObject *robj = PyObject_CallMethod($result, (char *)"__deref__", NULL);
-    if (robj && !PyErr_Occurred()) {
-      SwigPyObject_append((PyObject *) SWIG_Python_GetSwigThis($result), 
-			  (PyObject *) SWIG_Python_GetSwigThis(robj));
-      Py_DECREF(robj);
-    }
-  }
-}
-
diff --git a/share/swig/2.0.11/python/pyuserdir.swg b/share/swig/2.0.11/python/pyuserdir.swg
deleted file mode 100644
index d3c3eb1..0000000
--- a/share/swig/2.0.11/python/pyuserdir.swg
+++ /dev/null
@@ -1,246 +0,0 @@
-/* -------------------------------------------------------------------------
- *  Special user directives
- * ------------------------------------------------------------------------- */
-
-/* ------------------------------------------------------------------------- */
-
-/* shadow code */
-#define %shadow      %insert("shadow")
-#define %pythoncode  %insert("python")
-#define %pythonbegin %insert("pythonbegin")
-
-
-/* ------------------------------------------------------------------------- */
-/* 
-Use the "nondynamic" feature to make a wrapped class behave as a "nondynamic"
-one, ie, a python class that doesn't dynamically add new attributes.
-
-For example, for the class
-
-%pythonnondynamic A;
-struct A
-{
-  int a;
-  int b;
-};
-
-you will get:
-
- aa = A()
- aa.a = 1  # Ok
- aa.b = 1  # Ok
- aa.c = 3  # error
-
-Since nondynamic is a feature, if you use it like
-
- %pythonnondynamic;
-
-it will make all the wrapped classes nondynamic ones.
-
-The implementation is based on this recipe:
-
-   http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/252158
-
-and works for modern (-modern) and plain python. We do not use __slots__, 
-so, it works with old python versions.
-
-*/
-
-#define %pythonnondynamic      %feature("python:nondynamic", "1")
-#define %nopythonnondynamic    %feature("python:nondynamic", "0")
-#define %clearpythonnondynamic %feature("python:nondynamic", "")
-#define %pythondynamic         %nopythonnondynamic
-
-
-/* ------------------------------------------------------------------------- */
-/*
-
-Use %pythonmaybecall to flag a method like __add__ or __radd__.  These
-don't produce an error when called, they just return NotImplemented.
-
-These methods "may be called" if needed.
-
-*/
-
-#define %pythonmaybecall      %feature("python:maybecall", "1") 
-#define %nopythonmaybecall    %feature("python:maybecall", "0")
-#define %clearpythonmaybecall %feature("python:maybecall", "")
-
-/* ------------------------------------------------------------------------- */
-/*
-  The %pythoncallback feature produce a more natural callback wrapper
-  than the %callback mechanism, ie, it uses the original name for
-  the callback and callable objects. 
-
-  Just use it as
-
-    %pythoncallback(1) foo;
-    int foo(int a);
-
-    %pythoncallback(1) A::foo;
-    struct A {
-     static int foo(int a);
-    };
-
-    int bar(int, int (*pf)(int));
-
-  then, you can use it as:
-
-   a = foo(1)
-   b = bar(2, foo)
-
-   c = A.foo(3)
-   d = bar(4, A.foo)
-
-
-   If you use it with a member method
-   %pythoncallback(1) A::foom;
-   struct A {
-      int foom(int a);
-   };
-
-   then you can use it as
-
-     r = a.foom(3)             # eval the method
-     mptr = A.foom_cb_ptr      # returns the callback pointer
-
-   where the '_cb_ptr' suffix is added for the callback pointer.
-
-*/
-
-#define %pythoncallback      %feature("python:callback")
-#define %nopythoncallback    %feature("python:callback","0")
-#define %clearpythoncallback %feature("python:callback","")
-
-/* ------------------------------------------------------------------------- */
-/*
-  Support for the old %callback directive name
-*/
-#ifdef %callback
-#undef %callback
-#endif
-
-#ifdef %nocallback
-#undef %nocallback
-#endif
-
-#ifdef %clearcallback
-#undef %clearcallback
-#endif
-
-#define %callback(x)     %feature("python:callback",`x`)
-#define %nocallback      %nopythoncallback
-#define %clearcallback   %clearpythoncallback
-
-/* ------------------------------------------------------------------------- */
-/*
-  Thread support - Advance control
-  
-*/
-
-#define %nothread           %feature("nothread")
-#define %thread             %feature("nothread","0")
-#define %clearnothread      %feature("nothread","")
-
-#define %nothreadblock      %feature("nothreadblock")
-#define %threadblock        %feature("nothreadblock","0")
-#define %clearnothreadblock %feature("nothreadblock","")
-
-#define %nothreadallow      %feature("nothreadallow")
-#define %threadallow        %feature("nothreadallow","0")
-#define %clearnothreadallow %feature("nothreadallow","")
-
-
-/* ------------------------------------------------------------------------- */
-/*
-  Implicit Conversion using the C++ constructor mechanism
-*/
-
-#define %implicitconv      %feature("implicitconv") 
-#define %noimplicitconv    %feature("implicitconv", "0")
-#define %clearimplicitconv %feature("implicitconv", "")
-
-
-/* ------------------------------------------------------------------------- */
-/*
-  Enable keywords paramaters
-*/
-
-#define %kwargs      %feature("kwargs") 
-#define %nokwargs    %feature("kwargs", "0")
-#define %clearkwargs %feature("kwargs", "")
-
-/* ------------------------------------------------------------------------- */
-/*
-  Add python code to the proxy/shadow code 
-  
-   %pythonprepend   - Add code before the C++ function is called
-   %pythonappend    - Add code after the C++ function is called
-*/
-
-#define %pythonprepend       %feature("pythonprepend") 
-#define %clearpythonprepend  %feature("pythonprepend","")
-
-#define %pythonappend         %feature("pythonappend") 
-#define %clearpythonappend    %feature("pythonappend","")
-
-
-
-/* ------------------------------------------------------------------------- */
-/* 
-   %extend_smart_pointer extend the smart pointer support.
-
-   For example, if you have a smart pointer as:
-	    
-     template <class Type> class RCPtr {
-     public:
-       ...
-       RCPtr(Type *p);
-   	Type * operator->() const;
-   	...
-     };
-     
-   you use the %extend_smart_pointer directive as:
-   
-     %extend_smart_pointer(RCPtr<A>);
-     %template(RCPtr_A)  RCPtr<A>;
-   
-   then, if you have something like:
-
-     RCPtr<A> make_ptr();
-     int foo(A *);
-
-   you can do the following:
-
-     a = make_ptr();
-     b = foo(a);
-
-   ie, swig will accept a RCPtr<A> object where a 'A *' is
-   expected.
-
-   Also, when using vectors
-   
-     %extend_smart_pointer(RCPtr<A>);
-     %template(RCPtr_A) RCPtr<A>;
-     %template(vector_A) std::vector<RCPtr<A> >;
-   	
-   you can type
-
-     a = A();
-     v = vector_A(2)
-     v[0] = a
-
-   ie, an 'A *' object is accepted, via implicit conversion, 
-   where a RCPtr<A> object is expected. Additionally
-
-     x = v[0]
-
-   returns (and sets 'x' as) a copy of v[0], making reference
-   counting possible and consistent.
-*/
-
-%define %extend_smart_pointer(Type...)
-%implicitconv Type;
-%apply const SWIGTYPE& SMARTPOINTER { const Type& };
-%apply SWIGTYPE SMARTPOINTER { Type };
-%enddef
diff --git a/share/swig/2.0.11/python/pywstrings.swg b/share/swig/2.0.11/python/pywstrings.swg
deleted file mode 100644
index 864376b..0000000
--- a/share/swig/2.0.11/python/pywstrings.swg
+++ /dev/null
@@ -1,69 +0,0 @@
-/* ------------------------------------------------------------
- *  utility methods for wchar_t strings 
- * ------------------------------------------------------------ */
-
-%{
-#if PY_VERSION_HEX >= 0x03020000
-# define SWIGPY_UNICODE_ARG(obj) ((PyObject*) (obj))
-#else
-# define SWIGPY_UNICODE_ARG(obj) ((PyUnicodeObject*) (obj))
-#endif
-%}
-
-%fragment("SWIG_AsWCharPtrAndSize","header",fragment="<wchar.h>",fragment="SWIG_pwchar_descriptor") {
-SWIGINTERN int
-SWIG_AsWCharPtrAndSize(PyObject *obj, wchar_t **cptr, size_t *psize, int *alloc)
-{
-  PyObject *tmp = 0;
-  int isunicode = PyUnicode_Check(obj);
-%#if PY_VERSION_HEX < 0x03000000
-  if (!isunicode && PyString_Check(obj)) {
-    obj = tmp = PyUnicode_FromObject(obj);
-    isunicode = 1;
-  }
-%#endif
-  if (isunicode) {
-    Py_ssize_t len = PyUnicode_GetSize(obj);
-    if (cptr) {
-      *cptr = %new_array(len + 1, wchar_t);
-      PyUnicode_AsWideChar(SWIGPY_UNICODE_ARG(obj), *cptr, len);
-      (*cptr)[len] = 0;
-    }
-    if (psize) *psize = (size_t) len + 1;
-    if (alloc) *alloc = cptr ? SWIG_NEWOBJ : 0;
-    Py_XDECREF(tmp);
-    return SWIG_OK;
-  } else {
-    swig_type_info* pwchar_descriptor = SWIG_pwchar_descriptor();
-    if (pwchar_descriptor) {
-      void * vptr = 0;
-      if (SWIG_ConvertPtr(obj, &vptr, pwchar_descriptor, 0) == SWIG_OK) {
-	if (cptr) *cptr = (wchar_t *)vptr;
-	if (psize) *psize = vptr ? (wcslen((wchar_t *)vptr) + 1) : 0;
-	return SWIG_OK;
-      }
-    }
-  }
-  return SWIG_TypeError;
-}
-}
-
-%fragment("SWIG_FromWCharPtrAndSize","header",fragment="<wchar.h>",fragment="SWIG_pwchar_descriptor") {
-SWIGINTERNINLINE PyObject *
-SWIG_FromWCharPtrAndSize(const wchar_t * carray, size_t size)
-{
-  if (carray) {
-    if (size > INT_MAX) {
-      swig_type_info* pwchar_descriptor = SWIG_pwchar_descriptor();
-      return pwchar_descriptor ? 
-	SWIG_InternalNewPointerObj(%const_cast(carray,wchar_t *), pwchar_descriptor, 0) : SWIG_Py_Void();
-    } else {
-      return PyUnicode_FromWideChar(carray, %numeric_cast(size,int));
-    }
-  } else {
-    return SWIG_Py_Void();
-  }
-}
-}
-
-
diff --git a/share/swig/2.0.11/python/std_common.i b/share/swig/2.0.11/python/std_common.i
deleted file mode 100644
index 401bbde..0000000
--- a/share/swig/2.0.11/python/std_common.i
+++ /dev/null
@@ -1,74 +0,0 @@
-%include <std/std_except.i>
-%include <pystdcommon.swg>
-
-
-/*
-  Generate the traits for a 'primitive' type, such as 'double',
-  for which the SWIG_AsVal and SWIG_From methods are already defined.
-*/
-
-%define %traits_ptypen(Type...)
-  %fragment(SWIG_Traits_frag(Type),"header",
-	    fragment=SWIG_AsVal_frag(Type),
-	    fragment=SWIG_From_frag(Type),
-	    fragment="StdTraits") {
-namespace swig {
-  template <> struct traits<Type > {
-    typedef value_category category;
-    static const char* type_name() { return  #Type; }
-  };  
-  template <>  struct traits_asval<Type > {   
-    typedef Type value_type;
-    static int asval(PyObject *obj, value_type *val) { 
-      return SWIG_AsVal(Type)(obj, val);
-    }
-  };
-  template <>  struct traits_from<Type > {
-    typedef Type value_type;
-    static PyObject *from(const value_type& val) {
-      return SWIG_From(Type)(val);
-    }
-  };
-}
-}
-%enddef
-
-/* Traits for enums. This is bit of a sneaky trick needed because a generic template specialization of enums
-   is not possible (unless using template meta-programming which SWIG doesn't support because of the explicit
-   instantiations required using %template). The STL containers define the 'front' method and the typemap
-   below is used whenever the front method is wrapped returning an enum. This typemap simply picks up the
-   standard enum typemap, but additionally drags in a fragment containing the traits_asval and traits_from
-   required in the generated code for enums. */
-
-%define %traits_enum(Type...)
-  %fragment("SWIG_Traits_enum_"{Type},"header",
-	    fragment=SWIG_AsVal_frag(int),
-	    fragment=SWIG_From_frag(int),
-	    fragment="StdTraits") {
-namespace swig {
-  template <>  struct traits_asval<Type > {   
-    typedef Type value_type;
-    static int asval(PyObject *obj, value_type *val) { 
-      return SWIG_AsVal(int)(obj, (int *)val);
-    }
-  };
-  template <>  struct traits_from<Type > {
-    typedef Type value_type;
-    static PyObject *from(const value_type& val) {
-      return SWIG_From(int)((int)val);
-    }
-  };
-}
-}
-%typemap(out, fragment="SWIG_Traits_enum_"{Type}) const enum SWIGTYPE& front %{$typemap(out, const enum SWIGTYPE&)%}
-%enddef
-
-
-%include <std/std_common.i>
-
-//
-// Generates the traits for all the known primitive
-// C++ types (int, double, ...)
-//
-%apply_cpptypes(%traits_ptypen);
-
diff --git a/share/swig/2.0.11/python/std_map.i b/share/swig/2.0.11/python/std_map.i
deleted file mode 100644
index 66ed68d..0000000
--- a/share/swig/2.0.11/python/std_map.i
+++ /dev/null
@@ -1,309 +0,0 @@
-/*
-  Maps
-*/
-
-%fragment("StdMapCommonTraits","header",fragment="StdSequenceTraits")
-{
-  namespace swig {
-    template <class ValueType>
-    struct from_key_oper 
-    {
-      typedef const ValueType& argument_type;
-      typedef  PyObject *result_type;
-      result_type operator()(argument_type v) const
-      {
-	return swig::from(v.first);
-      }
-    };
-
-    template <class ValueType>
-    struct from_value_oper 
-    {
-      typedef const ValueType& argument_type;
-      typedef  PyObject *result_type;
-      result_type operator()(argument_type v) const
-      {
-	return swig::from(v.second);
-      }
-    };
-
-    template<class OutIterator, class FromOper, class ValueType = typename OutIterator::value_type>
-    struct SwigPyMapIterator_T : SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper>
-    {
-      SwigPyMapIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
-	: SwigPyIteratorClosed_T<OutIterator,ValueType,FromOper>(curr, first, last, seq)
-      {
-      }
-    };
-
-
-    template<class OutIterator,
-	     class FromOper = from_key_oper<typename OutIterator::value_type> >
-    struct SwigPyMapKeyIterator_T : SwigPyMapIterator_T<OutIterator, FromOper>
-    {
-      SwigPyMapKeyIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
-	: SwigPyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
-      {
-      }
-    };
-
-    template<typename OutIter>
-    inline SwigPyIterator*
-    make_output_key_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
-    {
-      return new SwigPyMapKeyIterator_T<OutIter>(current, begin, end, seq);
-    }
-
-    template<class OutIterator,
-	     class FromOper = from_value_oper<typename OutIterator::value_type> >
-    struct SwigPyMapValueITerator_T : SwigPyMapIterator_T<OutIterator, FromOper>
-    {
-      SwigPyMapValueITerator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
-	: SwigPyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
-      {
-      }
-    };
-    
-
-    template<typename OutIter>
-    inline SwigPyIterator*
-    make_output_value_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
-    {
-      return new SwigPyMapValueITerator_T<OutIter>(current, begin, end, seq);
-    }
-  }
-}
-
-%fragment("StdMapTraits","header",fragment="StdMapCommonTraits")
-{
-  namespace swig {
-    template <class SwigPySeq, class K, class T, class Compare, class Alloc >
-    inline void
-    assign(const SwigPySeq& swigpyseq, std::map<K,T,Compare,Alloc > *map) {
-      typedef typename std::map<K,T,Compare,Alloc >::value_type value_type;
-      typename SwigPySeq::const_iterator it = swigpyseq.begin();
-      for (;it != swigpyseq.end(); ++it) {
-	map->insert(value_type(it->first, it->second));
-      }
-    }
-
-    template <class K, class T, class Compare, class Alloc>
-    struct traits_asptr<std::map<K,T,Compare,Alloc > >  {
-      typedef std::map<K,T,Compare,Alloc > map_type;
-      static int asptr(PyObject *obj, map_type **val) {
-	int res = SWIG_ERROR;
-	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
-	if (PyDict_Check(obj)) {
-	  SwigVar_PyObject items = PyObject_CallMethod(obj,(char *)"items",NULL);
-%#if PY_VERSION_HEX >= 0x03000000
-          /* In Python 3.x the ".items()" method returns a dict_items object */
-          items = PySequence_Fast(items, ".items() didn't return a sequence!");
-%#endif
-	  res = traits_asptr_stdseq<map_type, std::pair<K, T> >::asptr(items, val);
-	} else {
-	  map_type *p;
-	  res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<map_type>(),0);
-	  if (SWIG_IsOK(res) && val)  *val = p;
-	}
-	SWIG_PYTHON_THREAD_END_BLOCK;
-	return res;
-      }      
-    };
-      
-    template <class K, class T, class Compare, class Alloc >
-    struct traits_from<std::map<K,T,Compare,Alloc > >  {
-      typedef std::map<K,T,Compare,Alloc > map_type;
-      typedef typename map_type::const_iterator const_iterator;
-      typedef typename map_type::size_type size_type;
-
-      static PyObject *asdict(const map_type& map) {
-	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
-	size_type size = map.size();
-	int pysize = (size <= (size_type) INT_MAX) ? (int) size : -1;
-	if (pysize < 0) {
-	  PyErr_SetString(PyExc_OverflowError,
-			  "map size not valid in python");
-	  SWIG_PYTHON_THREAD_END_BLOCK;
-	  return NULL;
-	}
-	PyObject *obj = PyDict_New();
-	for (const_iterator i= map.begin(); i!= map.end(); ++i) {
-	  swig::SwigVar_PyObject key = swig::from(i->first);
-	  swig::SwigVar_PyObject val = swig::from(i->second);
-	  PyDict_SetItem(obj, key, val);
-	}
-	SWIG_PYTHON_THREAD_END_BLOCK;
-	return obj;
-      }
-                
-      static PyObject *from(const map_type& map) {
-	swig_type_info *desc = swig::type_info<map_type>();
-	if (desc && desc->clientdata) {
-	  return SWIG_InternalNewPointerObj(new map_type(map), desc, SWIG_POINTER_OWN);
-	} else {
-	  return asdict(map);
-	}
-      }
-    };
-  }
-}
-
-%define %swig_map_common(Map...)
-  %swig_sequence_iterator(Map);
-  %swig_container_methods(Map)
-
-#if defined(SWIGPYTHON_BUILTIN)
-  %feature("python:slot", "mp_length", functype="lenfunc") __len__;
-  %feature("python:slot", "mp_subscript", functype="binaryfunc") __getitem__;
-  %feature("python:slot", "tp_iter", functype="getiterfunc") key_iterator;
-
-  %extend {
-    %newobject iterkeys(PyObject **PYTHON_SELF);
-    swig::SwigPyIterator* iterkeys(PyObject **PYTHON_SELF) {
-      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
-    }
-      
-    %newobject itervalues(PyObject **PYTHON_SELF);
-    swig::SwigPyIterator* itervalues(PyObject **PYTHON_SELF) {
-      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
-    }
-
-    %newobject iteritems(PyObject **PYTHON_SELF);
-    swig::SwigPyIterator* iteritems(PyObject **PYTHON_SELF) {
-      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
-    }
-  }
-
-#else
-  %extend {
-    %pythoncode {def __iter__(self): return self.key_iterator()}    
-    %pythoncode {def iterkeys(self): return self.key_iterator()}
-    %pythoncode {def itervalues(self): return self.value_iterator()}
-    %pythoncode {def iteritems(self): return self.iterator()}
-  }
-#endif
-
-  %extend {
-    mapped_type const & __getitem__(const key_type& key) throw (std::out_of_range) {
-      Map::const_iterator i = self->find(key);
-      if (i != self->end())
-	return i->second;
-      else
-	throw std::out_of_range("key not found");
-    }
-
-    void __delitem__(const key_type& key) throw (std::out_of_range) {
-      Map::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 key_type& key) const {
-      Map::const_iterator i = self->find(key);
-      return i != self->end();
-    }
-    
-    PyObject* keys() {
-      Map::size_type size = self->size();
-      int pysize = (size <= (Map::size_type) INT_MAX) ? (int) size : -1;
-      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
-      if (pysize < 0) {
-	PyErr_SetString(PyExc_OverflowError,
-			"map size not valid in python");
-	SWIG_PYTHON_THREAD_END_BLOCK;
-	return NULL;
-      }
-      PyObject* keyList = PyList_New(pysize);
-      Map::const_iterator i = self->begin();
-      for (int j = 0; j < pysize; ++i, ++j) {
-	PyList_SET_ITEM(keyList, j, swig::from(i->first));
-      }
-      SWIG_PYTHON_THREAD_END_BLOCK;
-      return keyList;
-    }
-    
-    PyObject* values() {
-      Map::size_type size = self->size();
-      int pysize = (size <= (Map::size_type) INT_MAX) ? (int) size : -1;
-      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
-      if (pysize < 0) {
-	PyErr_SetString(PyExc_OverflowError,
-			"map size not valid in python");
-	SWIG_PYTHON_THREAD_END_BLOCK;
-	return NULL;
-      }
-      PyObject* valList = PyList_New(pysize);
-      Map::const_iterator i = self->begin();
-      for (int j = 0; j < pysize; ++i, ++j) {
-	PyList_SET_ITEM(valList, j, swig::from(i->second));
-      }
-      SWIG_PYTHON_THREAD_END_BLOCK;
-      return valList;
-    }
-    
-    PyObject* items() {
-      Map::size_type size = self->size();
-      int pysize = (size <= (Map::size_type) INT_MAX) ? (int) size : -1;
-      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
-      if (pysize < 0) {
-	PyErr_SetString(PyExc_OverflowError,
-			"map size not valid in python");
-	SWIG_PYTHON_THREAD_END_BLOCK;
-	return NULL;
-      }    
-      PyObject* itemList = PyList_New(pysize);
-      Map::const_iterator i = self->begin();
-      for (int j = 0; j < pysize; ++i, ++j) {
-	PyList_SET_ITEM(itemList, j, swig::from(*i));
-      }
-      SWIG_PYTHON_THREAD_END_BLOCK;
-      return itemList;
-    }
-    
-    // Python 2.2 methods
-    bool __contains__(const key_type& key) {
-      return self->find(key) != self->end();
-    }
-
-    %newobject key_iterator(PyObject **PYTHON_SELF);
-    swig::SwigPyIterator* key_iterator(PyObject **PYTHON_SELF) {
-      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
-    }
-
-    %newobject value_iterator(PyObject **PYTHON_SELF);
-    swig::SwigPyIterator* value_iterator(PyObject **PYTHON_SELF) {
-      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
-    }
-  }
-
-%enddef
-
-%define %swig_map_methods(Map...)
-  %swig_map_common(Map)
-
-#if defined(SWIGPYTHON_BUILTIN)
-  %feature("python:slot", "mp_ass_subscript", functype="objobjargproc") __setitem__;
-#endif
-
-  %extend {
-    // This will be called through the mp_ass_subscript slot to delete an entry.
-    void __setitem__(const key_type& key) {
-      self->erase(key);
-    }
-
-    void __setitem__(const key_type& key, const mapped_type& x) throw (std::out_of_range) {
-      (*self)[key] = x;
-    }
-
-    PyObject* asdict() {
-      return swig::traits_from< Map >::asdict(*self);
-    }
-  }
-
-
-%enddef
-
-
-%include <std/std_map.i>
diff --git a/share/swig/2.0.11/python/std_multimap.i b/share/swig/2.0.11/python/std_multimap.i
deleted file mode 100644
index c81e2ac..0000000
--- a/share/swig/2.0.11/python/std_multimap.i
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
-  Multimaps
-*/
-%include <std_map.i>
-
-%fragment("StdMultimapTraits","header",fragment="StdMapCommonTraits")
-{
-  namespace swig {
-    template <class SwigPySeq, class K, class T >
-    inline void 
-    assign(const SwigPySeq& swigpyseq, std::multimap<K,T > *multimap) {
-      typedef typename std::multimap<K,T>::value_type value_type;
-      typename SwigPySeq::const_iterator it = swigpyseq.begin();
-      for (;it != swigpyseq.end(); ++it) {
-	multimap->insert(value_type(it->first, it->second));
-      }
-    }
-
-    template <class K, class T>
-    struct traits_asptr<std::multimap<K,T> >  {
-      typedef std::multimap<K,T> multimap_type;
-      static int asptr(PyObject *obj, std::multimap<K,T> **val) {
-	int res = SWIG_ERROR;
-	if (PyDict_Check(obj)) {
-	  SwigVar_PyObject items = PyObject_CallMethod(obj,(char *)"items",NULL);
-	  return traits_asptr_stdseq<std::multimap<K,T>, std::pair<K, T> >::asptr(items, val);
-	} else {
-	  multimap_type *p;
-	  res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<multimap_type>(),0);
-	  if (SWIG_IsOK(res) && val)  *val = p;
-	}
-	return res;
-      }
-    };
-      
-    template <class K, class T >
-    struct traits_from<std::multimap<K,T> >  {
-      typedef std::multimap<K,T> multimap_type;
-      typedef typename multimap_type::const_iterator const_iterator;
-      typedef typename multimap_type::size_type size_type;
-            
-      static PyObject *from(const multimap_type& multimap) {
-	swig_type_info *desc = swig::type_info<multimap_type>();
-	if (desc && desc->clientdata) {
-	  return SWIG_InternalNewPointerObj(new multimap_type(multimap), desc, SWIG_POINTER_OWN);
-	} else {
-	  size_type size = multimap.size();
-	  int pysize = (size <= (size_type) INT_MAX) ? (int) size : -1;
-	  if (pysize < 0) {
-	    SWIG_PYTHON_THREAD_BEGIN_BLOCK;
-	    PyErr_SetString(PyExc_OverflowError,
-			    "multimap size not valid in python");
-	    SWIG_PYTHON_THREAD_END_BLOCK;
-	    return NULL;
-	  }
-	  PyObject *obj = PyDict_New();
-	  for (const_iterator i= multimap.begin(); i!= multimap.end(); ++i) {
-	    swig::SwigVar_PyObject key = swig::from(i->first);
-	    swig::SwigVar_PyObject val = swig::from(i->second);
-	    PyDict_SetItem(obj, key, val);
-	  }
-	  return obj;
-	}
-      }
-    };
-  }
-}
-
-%define %swig_multimap_methods(Type...) 
-  %swig_map_common(Type);
-  %extend {
-    void __setitem__(const key_type& key, const mapped_type& x) throw (std::out_of_range) {
-      self->insert(Type::value_type(key,x));
-    }
-  }
-%enddef
-
-%include <std/std_multimap.i>
-
diff --git a/share/swig/2.0.11/python/std_pair.i b/share/swig/2.0.11/python/std_pair.i
deleted file mode 100644
index 7829695..0000000
--- a/share/swig/2.0.11/python/std_pair.i
+++ /dev/null
@@ -1,196 +0,0 @@
-/*
-  Pairs
-*/
-%include <pystdcommon.swg>
-
-//#define SWIG_STD_PAIR_ASVAL
-
-%fragment("StdPairTraits","header",fragment="StdTraits") {
-  namespace swig {
-#ifdef SWIG_STD_PAIR_ASVAL
-    template <class T, class U >
-    struct traits_asval<std::pair<T,U> >  {
-      typedef std::pair<T,U> value_type;
-
-      static int get_pair(PyObject* first, PyObject* second,
-			  std::pair<T,U> *val)
-      {
-	if (val) {
-	  T *pfirst = &(val->first);
-	  int res1 = swig::asval((PyObject*)first, pfirst);
-	  if (!SWIG_IsOK(res1)) return res1;
-	  U *psecond = &(val->second);
-	  int res2 = swig::asval((PyObject*)second, psecond);
-	  if (!SWIG_IsOK(res2)) return res2;
-	  return res1 > res2 ? res1 : res2;
-	} else {
-	  T *pfirst = 0;
-	  int res1 = swig::asval((PyObject*)first, 0);
-	  if (!SWIG_IsOK(res1)) return res1;
-	  U *psecond = 0;
-	  int res2 = swig::asval((PyObject*)second, psecond);
-	  if (!SWIG_IsOK(res2)) return res2;
-	  return res1 > res2 ? res1 : res2;
-	}	
-      }
-
-      static int asval(PyObject *obj, std::pair<T,U> *val) {
-	int res = SWIG_ERROR;
-	if (PyTuple_Check(obj)) {
-	  if (PyTuple_GET_SIZE(obj) == 2) {
-	    res = get_pair(PyTuple_GET_ITEM(obj,0),PyTuple_GET_ITEM(obj,1), val);
-	  }
-	} else if (PySequence_Check(obj)) {
-	  if (PySequence_Size(obj) == 2) {
-	    swig::SwigVar_PyObject first = PySequence_GetItem(obj,0);
-	    swig::SwigVar_PyObject second = PySequence_GetItem(obj,1);
-	    res = get_pair(first, second, val);
-	  }
-	} else {
-	  value_type *p;
-	  res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<value_type>(),0);
-	  if (SWIG_IsOK(res) && val)  *val = *p;
-	}
-	return res;
-      }
-    };
-
-#else
-    template <class T, class U >
-    struct traits_asptr<std::pair<T,U> >  {
-      typedef std::pair<T,U> value_type;
-
-      static int get_pair(PyObject* first, PyObject* second,
-			  std::pair<T,U> **val) 
-      {
-	if (val) {
-	  value_type *vp = %new_instance(std::pair<T,U>);
-	  T *pfirst = &(vp->first);
-	  int res1 = swig::asval((PyObject*)first, pfirst);
-	  if (!SWIG_IsOK(res1)) return res1;
-	  U *psecond = &(vp->second);
-	  int res2 = swig::asval((PyObject*)second, psecond);
-	  if (!SWIG_IsOK(res2)) return res2;
-	  *val = vp;
-	  return SWIG_AddNewMask(res1 > res2 ? res1 : res2);
-	} else {
-	  T *pfirst = 0;
-	  int res1 = swig::asval((PyObject*)first, pfirst);
-	  if (!SWIG_IsOK(res1)) return res1;
-	  U *psecond = 0;
-	  int res2 = swig::asval((PyObject*)second, psecond);
-	  if (!SWIG_IsOK(res2)) return res2;
-	  return res1 > res2 ? res1 : res2;
-	}	
-      }
-
-      static int asptr(PyObject *obj, std::pair<T,U> **val) {
-	int res = SWIG_ERROR;
-	if (PyTuple_Check(obj)) {
-	  if (PyTuple_GET_SIZE(obj) == 2) {
-	    res = get_pair(PyTuple_GET_ITEM(obj,0),PyTuple_GET_ITEM(obj,1), val);
-	  }
-	} else if (PySequence_Check(obj)) {
-	  if (PySequence_Size(obj) == 2) {
-	    swig::SwigVar_PyObject first = PySequence_GetItem(obj,0);
-	    swig::SwigVar_PyObject second = PySequence_GetItem(obj,1);
-	    res = get_pair(first, second, val);
-	  }
-	} else {
-	  value_type *p;
-	  res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<value_type>(),0);
-	  if (SWIG_IsOK(res) && val)  *val = p;
-	}
-	return res;
-      }
-    };
-
-#endif
-    template <class T, class U >
-    struct traits_from<std::pair<T,U> >   {
-      static PyObject *from(const std::pair<T,U>& val) {
-	PyObject* obj = PyTuple_New(2);
-	PyTuple_SetItem(obj,0,swig::from(val.first));
-	PyTuple_SetItem(obj,1,swig::from(val.second));
-	return obj;
-      }
-    };
-  }
-
-#if defined(SWIGPYTHON_BUILTIN)
-SWIGINTERN Py_ssize_t
-SwigPython_std_pair_len (PyObject *a)
-{
-    return 2;
-}
-
-SWIGINTERN PyObject*
-SwigPython_std_pair_repr (PyObject *o)
-{
-    PyObject *tuple = PyTuple_New(2);
-    assert(tuple);
-    PyTuple_SET_ITEM(tuple, 0, PyObject_GetAttrString(o, (char*) "first"));
-    PyTuple_SET_ITEM(tuple, 1, PyObject_GetAttrString(o, (char*) "second"));
-    PyObject *result = PyObject_Repr(tuple);
-    Py_DECREF(tuple);
-    return result;
-}
-
-SWIGINTERN PyObject*
-SwigPython_std_pair_getitem (PyObject *a, Py_ssize_t b)
-{
-    PyObject *result = PyObject_GetAttrString(a, b % 2 ? (char*) "second" : (char*) "first");
-    return result;
-}
-
-SWIGINTERN int
-SwigPython_std_pair_setitem (PyObject *a, Py_ssize_t b, PyObject *c)
-{
-    int result = PyObject_SetAttrString(a, b % 2 ? (char*) "second" : (char*) "first", c);
-    return result;
-}
-#endif
-
-}
-
-%feature("python:sq_length") std::pair "SwigPython_std_pair_len";
-%feature("python:sq_length") std::pair<T*,U> "SwigPython_std_pair_len";
-%feature("python:sq_length") std::pair<T,U*> "SwigPython_std_pair_len";
-%feature("python:sq_length") std::pair<T*,U*> "SwigPython_std_pair_len";
-
-%feature("python:tp_repr") std::pair "SwigPython_std_pair_repr";
-%feature("python:tp_repr") std::pair<T*,U> "SwigPython_std_pair_repr";
-%feature("python:tp_repr") std::pair<T,U*> "SwigPython_std_pair_repr";
-%feature("python:tp_repr") std::pair<T*,U*> "SwigPython_std_pair_repr";
-
-%feature("python:sq_item") std::pair "SwigPython_std_pair_getitem";
-%feature("python:sq_item") std::pair<T*,U> "SwigPython_std_pair_getitem";
-%feature("python:sq_item") std::pair<T,U*> "SwigPython_std_pair_getitem";
-%feature("python:sq_item") std::pair<T*,U*> "SwigPython_std_pair_getitem";
-
-%feature("python:sq_ass_item") std::pair "SwigPython_std_pair_setitem";
-%feature("python:sq_ass_item") std::pair<T*,U> "SwigPython_std_pair_setitem";
-%feature("python:sq_ass_item") std::pair<T,U*> "SwigPython_std_pair_setitem";
-%feature("python:sq_ass_item") std::pair<T*,U*> "SwigPython_std_pair_setitem";
-
-%define %swig_pair_methods(pair...)
-#if !defined(SWIGPYTHON_BUILTIN)
-%extend {      
-%pythoncode {def __len__(self): return 2
-def __repr__(self): return str((self.first, self.second))
-def __getitem__(self, index): 
-  if not (index % 2): 
-    return self.first
-  else:
-    return self.second
-def __setitem__(self, index, val):
-  if not (index % 2): 
-    self.first = val
-  else:
-    self.second = val}
-}
-#endif
-%enddef
-
-%include <std/std_pair.i>
-
diff --git a/share/swig/2.0.11/python/std_vector.i b/share/swig/2.0.11/python/std_vector.i
deleted file mode 100644
index 3f04a30..0000000
--- a/share/swig/2.0.11/python/std_vector.i
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
-  Vectors
-*/
-
-%fragment("StdVectorTraits","header",fragment="StdSequenceTraits")
-%{
-  namespace swig {
-    template <class T>
-    struct traits_asptr<std::vector<T> >  {
-      static int asptr(PyObject *obj, std::vector<T> **vec) {
-	return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
-      }
-    };
-    
-    template <class T>
-    struct traits_from<std::vector<T> > {
-      static PyObject *from(const std::vector<T>& vec) {
-	return traits_from_stdseq<std::vector<T> >::from(vec);
-      }
-    };
-  }
-%}
-
-#define %swig_vector_methods(Type...) %swig_sequence_methods(Type)
-#define %swig_vector_methods_val(Type...) %swig_sequence_methods_val(Type);
-
-%include <std/std_vector.i>
diff --git a/share/swig/2.0.11/r/boost_shared_ptr.i b/share/swig/2.0.11/r/boost_shared_ptr.i
deleted file mode 100644
index 17e9cfe..0000000
--- a/share/swig/2.0.11/r/boost_shared_ptr.i
+++ /dev/null
@@ -1,307 +0,0 @@
-%include <shared_ptr.i>
-
-// Language specific macro implementing all the customisations for handling the smart pointer
-%define SWIG_SHARED_PTR_TYPEMAPS(CONST, TYPE...)
-
-// %naturalvar is as documented for member variables
-%naturalvar TYPE;
-%naturalvar SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
-
-// destructor wrapper customisation
-%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) CONST TYPE (void *argp, int res = 0) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (!argp) {
-    %argument_nullref("$type", $symname, $argnum);
-  } else {
-    $1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
-    if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-  }
-}
-%typemap(out) CONST TYPE {
-  %set_output(SWIG_NewPointerObj(new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1)), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-%typemap(varin) CONST TYPE {
-  void *argp = 0;
-  int newmem = 0;
-  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res, "$type", "$name");
-  }
-  if (!argp) {
-    %argument_nullref("$type", $symname, $argnum);
-  } else {
-    $1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
-    if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-  }
-}
-%typemap(varout) CONST TYPE {
-  %set_varoutput(SWIG_NewPointerObj(new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1)), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-// plain pointer
-// Note: $disown not implemented as it will lead to a memory leak of the shared_ptr instance
-%typemap(in) CONST TYPE * (void  *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (newmem & SWIG_CAST_NEW_MEMORY) {
-    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    $1 = %const_cast(tempshared.get(), $1_ltype);
-  } else {
-    smartarg = %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
-  }
-}
-%typemap(out, fragment="SWIG_null_deleter") CONST TYPE * {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
-  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), $owner | SWIG_POINTER_OWN));
-}
-
-%typemap(varin) CONST TYPE * {
-  void *argp = 0;
-  int newmem = 0;
-  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res, "$type", "$name");
-  }
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0;
-  if (newmem & SWIG_CAST_NEW_MEMORY) {
-    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    $1 = %const_cast(tempshared.get(), $1_ltype);
-  } else {
-    smartarg = %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
-  }
-}
-%typemap(varout, fragment="SWIG_null_deleter") CONST TYPE * {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_0) : 0;
-  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-// plain reference
-%typemap(in) CONST TYPE & (void  *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (!argp) { %argument_nullref("$type", $symname, $argnum); }
-  if (newmem & SWIG_CAST_NEW_MEMORY) {
-    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    $1 = %const_cast(tempshared.get(), $1_ltype);
-  } else {
-    $1 = %const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
-  }
-}
-%typemap(out, fragment="SWIG_null_deleter") CONST TYPE & {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner);
-  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-%typemap(varin) CONST TYPE & {
-  void *argp = 0;
-  int newmem = 0;
-  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res, "$type", "$name");
-  }
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
-  if (!argp) { %argument_nullref("$type", $symname, $argnum); }
-  if (newmem & SWIG_CAST_NEW_MEMORY) {
-    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    $1 = *%const_cast(tempshared.get(), $1_ltype);
-  } else {
-    $1 = *%const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
-  }
-}
-%typemap(varout, fragment="SWIG_null_deleter") CONST TYPE & {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(&$1 SWIG_NO_NULL_DELETER_0);
-  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-// plain pointer by reference
-// Note: $disown not implemented as it will lead to a memory leak of the shared_ptr instance
-%typemap(in) TYPE *CONST& (void  *argp = 0, int res = 0, $*1_ltype temp = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (newmem & SWIG_CAST_NEW_MEMORY) {
-    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
-    temp = %const_cast(tempshared.get(), $*1_ltype);
-  } else {
-    temp = %const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $*1_ltype);
-  }
-  $1 = &temp;
-}
-%typemap(out, fragment="SWIG_null_deleter") TYPE *CONST& {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1 SWIG_NO_NULL_DELETER_$owner);
-  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-%typemap(varin) TYPE *CONST& %{
-#error "varin typemap not implemented"
-%}
-%typemap(varout) TYPE *CONST& %{
-#error "varout typemap not implemented"
-%}
-
-// shared_ptr by value
-%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > (void *argp, int res = 0) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (argp) $1 = *(%reinterpret_cast(argp, $&ltype));
-  if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $&ltype);
-}
-%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
-  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
-  int newmem = 0;
-  void *argp = 0;
-  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res, "$type", "$name");
-  }
-  $1 = argp ? *(%reinterpret_cast(argp, $&ltype)) : SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE >();
-  if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $&ltype);
-}
-%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
-  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-// shared_ptr by reference
-%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & (void *argp, int res = 0, $*1_ltype tempshared) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (newmem & SWIG_CAST_NEW_MEMORY) {
-    if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
-    delete %reinterpret_cast(argp, $ltype);
-    $1 = &tempshared;
-  } else {
-    $1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
-  }
-}
-%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
-  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
-#error "varin typemap not implemented"
-%}
-%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
-#error "varout typemap not implemented"
-%}
-
-// shared_ptr by pointer
-%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * (void *argp, int res = 0, $*1_ltype tempshared) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (newmem & SWIG_CAST_NEW_MEMORY) {
-    if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
-    delete %reinterpret_cast(argp, $ltype);
-    $1 = &tempshared;
-  } else {
-    $1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
-  }
-}
-%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 && *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
-  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-  if ($owner) delete $1;
-}
-
-%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
-#error "varin typemap not implemented"
-%}
-%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
-#error "varout typemap not implemented"
-%}
-
-// shared_ptr by pointer reference
-%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& (void *argp, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, $*1_ltype temp = 0) {
-  int newmem = 0;
-  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (argp) tempshared = *%reinterpret_cast(argp, $*ltype);
-  if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $*ltype);
-  temp = &tempshared;
-  $1 = &temp;
-}
-%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 && **$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(**$1) : 0;
-  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
-}
-
-%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
-#error "varin typemap not implemented"
-%}
-%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
-#error "varout typemap not implemented"
-%}
-
-// Typecheck typemaps
-// Note: SWIG_ConvertPtr with void ** parameter set to 0 instead of using SWIG_ConvertPtrAndOwn, so that the casting 
-// function is not called thereby avoiding a possible smart pointer copy constructor call when casting up the inheritance chain.
-%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1) 
-                      TYPE CONST,
-                      TYPE CONST &,
-                      TYPE CONST *,
-                      TYPE *CONST&,
-                      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 > *& {
-  int res = SWIG_ConvertPtr($input, 0, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), 0);
-  $1 = SWIG_CheckState(res);
-}
-
-
-// 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"
-%}
-
-
-%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
-%enddef
-
diff --git a/share/swig/2.0.11/r/r.swg b/share/swig/2.0.11/r/r.swg
deleted file mode 100644
index 126611d..0000000
--- a/share/swig/2.0.11/r/r.swg
+++ /dev/null
@@ -1,272 +0,0 @@
-/* */
-
-
-%insert("header") "swiglabels.swg"
-
-%insert("header") "swigerrors.swg"
-%insert("init") "swiginit.swg"
-%insert("runtime") "swigrun.swg"
-%insert("runtime") "rrun.swg"
-
-%init %{
-SWIGEXPORT void SWIG_init(void) {
-%}
-
-%include <rkw.swg>
-
-#define %Rruntime %insert("s")
-
-#define SWIG_Object SEXP
-#define VOID_Object R_NilValue
-
-#define %append_output(obj) SET_VECTOR_ELT($result, $n, obj)
-
-%define %set_constant(name, obj) %begin_block
-   SEXP _obj = obj;
-   assign(name, _obj);
-%end_block %enddef
-
-%define %raise(obj,type,desc) 
-return R_NilValue;
-%enddef
-
-%insert("sinit") "srun.swg"
-
-%insert("sinitroutine") %{
-SWIG_init();
-SWIG_InitializeModule(0);
-%}
-
-%include <typemaps/swigmacros.swg>
-%typemap(in) (double *x, int len) %{
-   $1 = REAL(x);
-   $2 = Rf_length(x);
-%}
-
-/* XXX
-   Need to worry about inheritance, e.g. if B extends A 
-   and we are looking for an A[], then B elements are okay.
-*/
-%typemap(scheck) SWIGTYPE[ANY]  
-  %{ 
-#      assert(length($input) > $1_dim0)
-      assert(all(sapply($input, class) == "$R_class"));
-  %}
-
-%typemap(out) void "";
-
-%typemap(in) int *, int[ANY],
-	     signed int *, signed int[ANY],
-	     unsigned int *, unsigned int[ANY],
-             short *, short[ANY],
-             signed short *, signed short[ANY],
-             unsigned short *, unsigned short[ANY],
-             long *, long[ANY],
-             signed long *, signed long[ANY],
-             unsigned long *, unsigned long[ANY],
-             long long *, long long[ANY],
-             signed long long *, signed long long[ANY],
-             unsigned long long *, unsigned long long[ANY]
-             
-{
-{ int _rswigi;
-  int _rswiglen = LENGTH($input);
-  $1 = %static_cast(calloc(sizeof($1_basetype), _rswiglen), $1_ltype);
-  for (_rswigi=0; _rswigi< _rswiglen; _rswigi++) {
-     $1[_rswigi] = INTEGER($input)[_rswigi];
-  }
-}
-} 
-
-%typemap(in) float *, float[ANY],
-             double *, double[ANY]
-             
-{
-{  int _rswigi;
-  int _rswiglen = LENGTH($input);
-  $1 = %static_cast(calloc(sizeof($1_basetype), _rswiglen), $1_ltype);
-  for (_rswigi=0; _rswigi<_rswiglen; _rswigi++) {
-     $1[_rswigi] = REAL($input)[_rswigi];
-  }
-}
-}
-
-%typemap(freearg,noblock=1) int *, int[ANY], 
-	     signed int *, signed int[ANY],
-	     unsigned int *, unsigned int[ANY],
-             short *, short[ANY],
-             signed short *, signed short[ANY],
-             unsigned short *, unsigned short[ANY],
-             long *, long[ANY],
-             signed long *, signed long[ANY],
-             unsigned long *, unsigned long[ANY],
-             long long *, long long[ANY],
-             signed long long *, signed long long[ANY],
-             unsigned long long *, unsigned long long[ANY],
-             float *, float[ANY],
-             double *, double[ANY]
-%{             
-  free($1);
-%}
-
-%typemap(freearg, noblock=1) int *OUTPUT,
-signed int *OUTPUT,
-unsigned int *OUTPUT,
-short *OUTPUT,
-signed short *OUTPUT,
-unsigned short *OUTPUT,
-long *OUTPUT,
-signed long *OUTPUT,
-unsigned long *OUTPUT,
-long long *OUTPUT,
-signed long long *OUTPUT,
-unsigned long long *OUTPUT,
-float *OUTPUT,
-double *OUTPUT,
-char *OUTPUT,
-signed char *OUTPUT,
-unsigned char *OUTPUT
-{}
-
-
-
-/* Should we recycle to make the length correct.
-   And warn if length() > the dimension. 
-*/
-%typemap(scheck) SWIGTYPE [ANY] %{
-#  assert(length($input) >= $1_dim0)
-%}
-
-/* Handling vector case to avoid warnings,
-   although we just use the first one. */
-%typemap(scheck) unsigned int %{
-  assert(length($input) == 1 && $input >= 0, "All values must be non-negative");
-%}
-
-
-%typemap(scheck) int, long %{
-  if(length($input) > 1) {
-     warning("using only the first element of $input");
-  };
-%}
-
-%include <typemaps/fragments.swg>
-%include <rfragments.swg>
-%include <ropers.swg>
-%include <typemaps/swigtypemaps.swg>
-%include <rtype.swg>
-
-%typemap(in,noblock=1) enum SWIGTYPE[ANY] {
-   $1 = %reinterpret_cast(INTEGER($input), $1_ltype);
-}
-
-%typemap(in,noblock=1,fragment="SWIG_strdup") char * {
-   $1 = %reinterpret_cast(SWIG_strdup(CHAR(STRING_ELT($input, 0))), $1_ltype);
-}
-
-%typemap(freearg,noblock=1) char * {
-   free($1);
-}
-
-%typemap(in,noblock=1,fragment="SWIG_strdup") char *[ANY]  {
-   $1 = %reinterpret_cast(SWIG_strdup(CHAR(STRING_ELT($input, 0))), $1_ltype);
-}
-
-%typemap(freearg,noblock=1) char *[ANY]  {
-   free($1);
-}
-
-%typemap(in,noblock=1,fragment="SWIG_strdup") char[ANY] {
-    $1 = SWIG_strdup(CHAR(STRING_ELT($input, 0)));
-}
-
-%typemap(freearg,noblock=1) char[ANY] {
-    free($1);
-}
-
-%typemap(in,noblock=1,fragment="SWIG_strdup") char[] {
-    $1 = SWIG_strdup(CHAR(STRING_ELT($input, 0)));
-}
-
-%typemap(freearg,noblock=1) char[] {
-    free($1);
-}
-
-
-%typemap(memberin) char[] %{
-if ($input) strcpy($1, $input);
-else
-strcpy($1, "");
-%}
-
-%typemap(globalin) char[] %{
-if ($input) strcpy($1, $input);
-else
-strcpy($1, "");
-%}
-
-%typemap(out,noblock=1) char * 
- {  $result = $1 ? Rf_mkString(%reinterpret_cast($1,char *)) : R_NilValue; }
-
-%typemap(in,noblock=1) char {
-$1 = %static_cast(CHAR(STRING_ELT($input, 0))[0],$1_ltype);
-}
-
-%typemap(out) char 
- { 
-    char tmp[2] = "x";
-    tmp[0] = $1;    
-    $result = Rf_mkString(tmp); 
- }
-
-
-%typemap(in,noblock=1) int, long
-{
-  $1 = %static_cast(INTEGER($input)[0], $1_ltype);
-}
-
-%typemap(out,noblock=1) int, long
-  "$result = Rf_ScalarInteger($1);";
-
-
-%typemap(in,noblock=1) bool 
-  "$1 = LOGICAL($input)[0] ? true : false;";
-
-
-%typemap(out,noblock=1) bool 
-  "$result = Rf_ScalarLogical($1);";
-
-%typemap(in,noblock=1) 
-             float, 
-             double
-{
-  $1 = %static_cast(REAL($input)[0], $1_ltype); 
-}
-
-/* Why is this here ? */
-/* %typemap(out,noblock=1) unsigned int *
-  "$result = ScalarReal(*($1));"; */
-
-%Rruntime %{
-setMethod('[', "ExternalReference",
-function(x,i,j, ..., drop=TRUE) 
-if (!is.null(x$"__getitem__")) 
-sapply(i, function(n) x$"__getitem__"(i=as.integer(n-1))))
-
-setMethod('[<-' , "ExternalReference",
-function(x,i,j, ..., value) 
-if (!is.null(x$"__setitem__")) {
-sapply(1:length(i), function(n) 
-x$"__setitem__"(i=as.integer(i[n]-1), x=value[n]))
-x
-})
-
-setAs('ExternalReference', 'character',
-function(from) {if (!is.null(from$"__str__")) from$"__str__"()})
-
-setMethod('print', 'ExternalReference',
-function(x) {print(as(x, "character"))})
-%}
-
-
-
diff --git a/share/swig/2.0.11/r/rfragments.swg b/share/swig/2.0.11/r/rfragments.swg
deleted file mode 100644
index afb75c3..0000000
--- a/share/swig/2.0.11/r/rfragments.swg
+++ /dev/null
@@ -1,183 +0,0 @@
-#define SWIG_Error(code, msg) Rf_warning(msg); return Rf_ScalarLogical(NA_LOGICAL)
-
-#define SWIG_fail return Rf_ScalarLogical(NA_LOGICAL)
-
-/* for raw pointers */
-#define SWIG_ConvertPtr(oc, ptr, ty, flags)             SWIG_R_ConvertPtr(oc, ptr, ty, flags)
-#define SWIG_ConvertFunctionPtr(oc, ptr, ty)            SWIG_R_ConvertPtr(oc, ptr, ty, 0)
-#define SWIG_NewPointerObj(ptr, ty, flags)              SWIG_R_NewPointerObj(ptr, ty, flags)
-#define SWIG_NewFunctionPtrObj(ptr, ty)                 SWIG_R_NewPointerObj(ptr, ty, 0)
-
-/* for raw packed data */
-#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_R_ConvertPacked(obj, ptr, sz, ty)
-#define SWIG_NewPackedObj(ptr, sz, ty)                  SWIG_R_NewPackedObj(ptr, sz, ty)
-
-/* for class or struct pointers */
-#define SWIG_ConvertInstance(obj, pptr, ty, flags)      SWIG_ConvertPtr(obj, pptr, ty, flags)
-#define SWIG_NewInstanceObj(ptr, ty, flags)             SWIG_NewPointerObj(ptr, ty, flags)
-
-/* for C++ member pointers, ie, member methods */
-#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_R_ConvertPacked(obj, ptr, sz, ty)
-#define SWIG_NewMemberObj(ptr, sz, ty)                  SWIG_R_NewPackedObj(ptr, sz, ty)
-
-
-/* Runtime API */
-
-#define SWIG_GetModule(clientdata)                      SWIG_R_GetModule()
-#define SWIG_SetModule(clientdata, pointer)             SWIG_R_SetModule(pointer)
-
-%fragment(SWIG_From_frag(long),"header") {
-SWIGINTERNINLINE SEXP
-SWIG_From_dec(long)(long value)
-{
-	return Rf_ScalarInteger((int)value);
-}
-}
-
-%fragment(SWIG_AsVal_frag(long),"header") {
-SWIGINTERNINLINE  int
-SWIG_AsVal_dec(long)(SEXP obj, long *val)
-{
-   if (val) *val = Rf_asInteger(obj);
-   return SWIG_OK;
-}
-}
-
-
-%fragment(SWIG_From_frag(long long),"header") {
-SWIGINTERNINLINE SEXP
-SWIG_From_dec(long long)(long long value)
-{
-	return Rf_ScalarInteger((int)value);
-}
-}
-
-%fragment(SWIG_AsVal_frag(long long),"header") {
-SWIGINTERNINLINE  int
-SWIG_AsVal_dec(long long)(SEXP obj, long long *val)
-{
-   if (val) *val = Rf_asInteger(obj);
-   return SWIG_OK;
-}
-}
-
-%fragment(SWIG_From_frag(unsigned long),"header") {
-SWIGINTERNINLINE SEXP
-SWIG_From_dec(unsigned long)(unsigned long value)
-{
-	return Rf_ScalarInteger((int)value);
-}
-}
-
-
-%fragment(SWIG_AsVal_frag(unsigned long),"header") {
-SWIGINTERNINLINE  int
-SWIG_AsVal_dec(unsigned long)(SEXP obj, unsigned long *val)
-{
-   if (val) *val = Rf_asInteger(obj);
-   return SWIG_OK;
-}
-}
-
-
-%fragment(SWIG_From_frag(unsigned long long),"header") {
-SWIGINTERNINLINE SEXP
-SWIG_From_dec(unsigned long long)(unsigned long long value)
-{
-	return Rf_ScalarInteger((int)value);
-}
-}
-
-
-%fragment(SWIG_AsVal_frag(unsigned long long),"header") {
-SWIGINTERNINLINE  int
-SWIG_AsVal_dec(unsigned long long)(SEXP obj, unsigned long long *val)
-{
-   if (val) *val = Rf_asInteger(obj);
-   return SWIG_OK;
-}
-}
-
-%fragment(SWIG_From_frag(double),"header") {
-SWIGINTERNINLINE SEXP
-SWIG_From_dec(double)(double value)
-{
-	return Rf_ScalarReal(value);
-}
-}
-
-
-%fragment(SWIG_AsVal_frag(double),"header") {
-SWIGINTERNINLINE  int
-SWIG_AsVal_dec(double)(SEXP obj, double *val)
-{
-   if (val) *val = Rf_asReal(obj);
-   return SWIG_OK;
-}
-}
-
-%fragment("SWIG_AsCharPtrAndSize", "header") 
-{
-SWIGINTERN int
-SWIG_AsCharPtrAndSize(SEXP obj, char** cptr, size_t* psize, int *alloc)
-{
-  if (cptr && Rf_isString(obj)) {
-    char *cstr = %const_cast(CHAR(STRING_ELT(obj, 0)), char *);
-    int len = strlen(cstr);
-
-    if (alloc) {
-      if (*alloc == SWIG_NEWOBJ) {
-        *cptr = %new_copy_array(cstr, len + 1, char);
-        *alloc = SWIG_NEWOBJ;
-      } else {
-        *cptr = cstr;
-      }
-    } else {
-      *cptr = %reinterpret_cast(malloc(len + 1), char *);
-      *cptr = strcpy(*cptr, cstr);
-    }
-    if (psize) *psize = len + 1;
-    return SWIG_OK;
-  }
-  return SWIG_TypeError;
-}
-}
-
-%fragment("SWIG_strdup","header") 
-{
-SWIGINTERN char *
-SWIG_strdup(const char *str)
-{
-  char *newstr = %reinterpret_cast(malloc(strlen(str) + 1), char *);
-  return strcpy(newstr, str);
-}
-}
-
-# This is modified from the R header files
-
-%fragment("SWIG_FromCharPtrAndSize","header") 
-{
-SWIGINTERN SEXP
-SWIG_FromCharPtrAndSize(const char* carray, size_t size) 
-{
-  SEXP t, c;
-  if (!carray) return R_NilValue;
-/* See R internals document 1.10.  
-   MkCharLen was introduced in 2.7.0.  Use that instead of hand
-   creating vector.
-
-   Starting in 2.8.0 creating strings via vectors was deprecated in
-   order to allow for use of CHARSXP caches. */
-
-  Rf_protect(t = Rf_allocVector(STRSXP, 1));
-%#if R_VERSION >=  R_Version(2,7,0)
-  c = Rf_mkCharLen(carray, size);
-%#else
-  c = Rf_allocVector(CHARSXP, size);
-  strncpy((char *)CHAR(c), carray, size);
-%#endif
-  SET_STRING_ELT(t, 0, c);
-  Rf_unprotect(1);
-  return t;
-}
-}
diff --git a/share/swig/2.0.11/r/rkw.swg b/share/swig/2.0.11/r/rkw.swg
deleted file mode 100644
index 2c181fa..0000000
--- a/share/swig/2.0.11/r/rkw.swg
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
-  Warnings for R keywords, built-in names and bad names.
-*/
-
-#define RKW(x) %keywordwarn("'" `x` "' is a R keyword, renaming to '_" `x`"'", rename="_%s")  `x`
-
-/*
-  Warnings for R reserved words taken from
-  http://cran.r-project.org/doc/manuals/R-lang.html#Reserved-words
-*/
-
-RKW(if);
-RKW(else);
-RKW(repeat);
-RKW(while);
-RKW(function);
-RKW(for);
-RKW(in);
-RKW(next);
-RKW(break);
-RKW(TRUE);
-RKW(FALSE);
-RKW(NULL);
-RKW(Inf);
-RKW(NaN);
-RKW(NA);
-RKW(NA_integer_);
-RKW(NA_real_);
-RKW(NA_complex_);
-RKW(NA_character_);
-
-#undef RKW
diff --git a/share/swig/2.0.11/r/ropers.swg b/share/swig/2.0.11/r/ropers.swg
deleted file mode 100644
index c02f7b2..0000000
--- a/share/swig/2.0.11/r/ropers.swg
+++ /dev/null
@@ -1,70 +0,0 @@
-#ifdef __cplusplus
-
-// These are auto-supported by the Perl-module
-%rename(__plusplus__) *::operator++;
-%rename(__minmin__)   *::operator--;
-%rename(__add__)      *::operator+;
-%rename(__sub__)      *::operator-;
-%rename(__neg__)      *::operator-();
-%rename(__neg__)      *::operator-() const;
-%rename(__mul__)      *::operator*;
-%rename(__div__)      *::operator/;
-%rename(__eq__)       *::operator==;
-%rename(__ne__)       *::operator!=;
-%rename(__mod__)      *::operator%;
-%rename(__gt__)       *::operator>;
-%rename(__lt__)       *::operator<;
-%rename(__not__)      *::operator!;
-
-// These are renamed, but no 'use overload...' is added
-%rename(__lshift__)   *::operator<<;
-%rename(__rshift__)   *::operator>>;
-%rename(__and__)      *::operator&;
-%rename(__or__)       *::operator|;
-%rename(__xor__)      *::operator^;
-%rename(__invert__)   *::operator~;
-%rename(__le__)       *::operator<=;
-%rename(__ge__)       *::operator>=;
-%rename(__call__)     *::operator();
-%rename(__getitem__)  *::operator[];
-
-%rename(__seteq__)    *::operator=;
-
-
-%rename(__land__)       operator&&;
-%rename(__lor__)        operator||;
-%rename(__plusplus__)   *::operator++;
-%rename(__minusminus__) *::operator--;
-%rename(__arrowstar__)  *::operator->*;
-%rename(__index__)      *::operator[];
-
-%rename(Equal) operator =;
-%rename(PlusEqual) operator +=;
-%rename(MinusEqual) operator -=;
-%rename(MultiplyEqual) operator *=;
-%rename(DivideEqual) operator /=;
-%rename(PercentEqual) operator %=;
-%rename(Plus) operator +;
-%rename(Minus) operator -;
-%rename(Multiply) operator *;
-%rename(Divide) operator /;
-%rename(Percent) operator %;
-%rename(Not) operator !;
-%rename(IndexIntoConst) operator[](unsigned idx) const;
-%rename(IndexInto) operator[](unsigned idx);
-%rename(Functor) operator ();
-%rename(EqualEqual) operator ==;
-%rename(NotEqual) operator !=;
-%rename(LessThan) operator <;
-%rename(LessThanEqual) operator <=;
-%rename(GreaterThan) operator >;
-%rename(GreaterThanEqual) operator >=;
-%rename(And) operator &&;
-%rename(Or) operator ||;
-%rename(PlusPlusPrefix) operator++();
-%rename(PlusPlusPostfix) operator++(int);
-%rename(MinusMinusPrefix) operator--();
-%rename(MinusMinusPostfix) operator--(int);
-
-
-#endif
diff --git a/share/swig/2.0.11/r/rrun.swg b/share/swig/2.0.11/r/rrun.swg
deleted file mode 100644
index f8bc9f4..0000000
--- a/share/swig/2.0.11/r/rrun.swg
+++ /dev/null
@@ -1,380 +0,0 @@
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* for raw pointer */
-#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_R_ConvertPtr(obj, pptr, type, flags)
-#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_R_ConvertPtr(obj, pptr, type, flags)
-#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_R_NewPointerObj(ptr, type, flags)
-
-
-/* Remove global namespace pollution */
-#if !defined(SWIG_NO_R_NO_REMAP)
-# define R_NO_REMAP
-#endif
-#if !defined(SWIG_NO_STRICT_R_HEADERS)
-# define STRICT_R_HEADERS
-#endif
-
-#include <Rdefines.h>
-#include <Rversion.h>
-#include <stdlib.h>
-#include <assert.h>
-
-#if R_VERSION >= R_Version(2,6,0)
-#define VMAXTYPE void *
-#else
-#define VMAXTYPE char *
-#endif
-
-/*
-  This is mainly a way to avoid having lots of local variables that may 
-  conflict with those in the routine.
-
-   Change name to R_SWIG_Callb....
-*/
-typedef struct RCallbackFunctionData {
-
-  SEXP fun;
-  SEXP userData;
-
-
-  SEXP expr;
-  SEXP retValue;
-  int errorOccurred;
-
-  SEXP el;  /* Temporary pointer used in the construction of the expression to call the R function. */
-
-  struct RCallbackFunctionData *previous;   /* Stack */
-
-} RCallbackFunctionData;
-
-static RCallbackFunctionData  *callbackFunctionDataStack;
-
-
-SWIGRUNTIME SEXP
-R_SWIG_debug_getCallbackFunctionData()
-{
-  int n, i;
-  SEXP ans;
-  RCallbackFunctionData  *p = callbackFunctionDataStack;
-
-  n = 0;
-  while(p) { 
-    n++;
-    p = p->previous;
-  }
-
-  Rf_protect(ans = Rf_allocVector(VECSXP, n));
-  for(p = callbackFunctionDataStack, i = 0; i < n; p = p->previous, i++) 
-      SET_VECTOR_ELT(ans, i, p->fun);
-
-  Rf_unprotect(1);
-
-  return(ans);
-}
-
-
-
-SWIGRUNTIME RCallbackFunctionData *
-R_SWIG_pushCallbackFunctionData(SEXP fun, SEXP userData)
-{
-   RCallbackFunctionData *el;
-   el = (RCallbackFunctionData *) calloc(1, sizeof(RCallbackFunctionData));
-   el->fun = fun;
-   el->userData = userData;
-   el->previous = callbackFunctionDataStack;
-
-   callbackFunctionDataStack = el;
-
-   return(el);
-}
-
-
-SWIGRUNTIME SEXP
-R_SWIG_R_pushCallbackFunctionData(SEXP fun, SEXP userData)
-{
-    R_SWIG_pushCallbackFunctionData(fun, userData);
-    return R_NilValue;
-}
-
-SWIGRUNTIME RCallbackFunctionData *
-R_SWIG_getCallbackFunctionData()
-{
-  if(!callbackFunctionDataStack) {
-    Rf_error("Supposedly impossible error occurred in the SWIG callback mechanism."
-            "  No callback function data set.");
-  }
-  
-  return callbackFunctionDataStack;
-}
-
-SWIGRUNTIME void
-R_SWIG_popCallbackFunctionData(int doFree)
-{
-  RCallbackFunctionData  *el = NULL;
-  if(!callbackFunctionDataStack)
-    return ; /* Error !!! */
-
-  el = callbackFunctionDataStack ;
-  callbackFunctionDataStack = callbackFunctionDataStack->previous;
-
-  if(doFree)
-     free(el);
-}
-
-
-/*
-  Interface to S function
-      is(obj, type)
-  which is to be used to determine if an 
-  external pointer inherits from the right class.
-
-  Ideally, we would like to be able to do this without an explicit call to the is() function.
-  When the S4 class system uses its own SEXP types, then we will hopefully be able to do this
-  in the C code.
-
-  Should we make the expression static and preserve it to avoid the overhead of 
-  allocating each time.
-*/
-SWIGRUNTIME int
-R_SWIG_checkInherits(SEXP obj, SEXP tag, const char *type)
-{
-  SEXP e, val;
-  int check_err = 0;
-
-  Rf_protect(e = Rf_allocVector(LANGSXP, 3));
-  SETCAR(e, Rf_install("extends"));
-
-  SETCAR(CDR(e), Rf_mkString(CHAR(PRINTNAME(tag))));
-  SETCAR(CDR(CDR(e)), Rf_mkString(type));
-
-  val = R_tryEval(e, R_GlobalEnv, &check_err);
-  Rf_unprotect(1);
-  if(check_err) 
-    return(0);
-
-
-  return(LOGICAL(val)[0]);
-}
-
-
-SWIGRUNTIME void *
-R_SWIG_resolveExternalRef(SEXP arg, const char * const type, const char * const argName, Rboolean nullOk)
-{
-  void *ptr;
-  SEXP orig = arg;
-
-  if(TYPEOF(arg) != EXTPTRSXP) 
-    arg = GET_SLOT(arg, Rf_mkString("ref"));
-
-  
-  if(TYPEOF(arg) != EXTPTRSXP) {
-    Rf_error("argument %s must be an external pointer (from an ExternalReference)", argName);
-  }
-
-
-  ptr = R_ExternalPtrAddr(arg);
-
-  if(ptr == NULL && nullOk == (Rboolean) FALSE) {
-    Rf_error("the external pointer (of type %s) for argument %s has value NULL", argName, type);
-  }
-
-  if(type[0] && R_ExternalPtrTag(arg) != Rf_install(type) && strcmp(type, "voidRef")
-      && !R_SWIG_checkInherits(orig,  R_ExternalPtrTag(arg), type)) {
-    Rf_error("the external pointer for argument %s has tag %s, not the expected value %s",
-             argName, CHAR(PRINTNAME(R_ExternalPtrTag(arg))), type);
-  }
-
-
-  return(ptr);
-}
-
-SWIGRUNTIME void
-R_SWIG_ReferenceFinalizer(SEXP el)
-{
-  void *ptr = R_SWIG_resolveExternalRef(el, "", "<finalizer>",  (Rboolean) 1);
-  fprintf(stderr, "In R_SWIG_ReferenceFinalizer for %p\n", ptr);
-  Rf_PrintValue(el);
-
-  if(ptr) {
-     if(TYPEOF(el) != EXTPTRSXP)
-        el = GET_SLOT(el, Rf_mkString("ref"));
-
-     if(TYPEOF(el) == EXTPTRSXP)
-        R_ClearExternalPtr(el);
-
-     free(ptr);
-  }
-
-  return;
-}
-
-typedef enum {R_SWIG_EXTERNAL, R_SWIG_OWNER } R_SWIG_Owner;
-
-SWIGRUNTIME SEXP
-SWIG_MakePtr(void *ptr, const char *typeName, R_SWIG_Owner owner)
-{
-  SEXP external, r_obj;
-  const char *p = typeName;
-
-  if(typeName[0] == '_')
-     p = typeName + 1;
-
-  Rf_protect(external = R_MakeExternalPtr(ptr, Rf_install(typeName), R_NilValue));
-  Rf_protect(r_obj = NEW_OBJECT(MAKE_CLASS((char *) typeName)));
-
-  if(owner)
-    R_RegisterCFinalizer(external, R_SWIG_ReferenceFinalizer);
-
-  r_obj = SET_SLOT(r_obj, Rf_mkString((char *) "ref"), external);
-  SET_S4_OBJECT(r_obj);
-  Rf_unprotect(2);
-
-  return(r_obj);
-}
-
-
-SWIGRUNTIME SEXP
-R_SWIG_create_SWIG_R_Array(const char *typeName, SEXP ref, int len)
-{
-   SEXP arr;
-
-/*XXX remove the char * cast when we can. MAKE_CLASS should be declared appropriately. */
-   Rf_protect(arr = NEW_OBJECT(MAKE_CLASS((char *) typeName)));
-   Rf_protect(arr = R_do_slot_assign(arr, Rf_mkString("ref"), ref));
-   Rf_protect(arr = R_do_slot_assign(arr, Rf_mkString("dims"), Rf_ScalarInteger(len)));
-
-   Rf_unprotect(3); 			   
-   SET_S4_OBJECT(arr);	
-   return arr;
-}
-
-#define ADD_OUTPUT_ARG(result, pos, value, name)  r_ans = AddOutputArgToReturn(pos, value, name, OutputValues);
-
-SWIGRUNTIME SEXP
-AddOutputArgToReturn(int pos, SEXP value, const char *name, SEXP output)
-{
-  SET_VECTOR_ELT(output, pos, value);
-
-  return(output);
-}
-
-/* Create a new pointer object */
-SWIGRUNTIMEINLINE SEXP
-SWIG_R_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
-  SEXP rptr = R_MakeExternalPtr(ptr, 
-  R_MakeExternalPtr(type, R_NilValue, R_NilValue), R_NilValue); 
-  SET_S4_OBJECT(rptr);
-  return rptr;
-}
-
-
-/* Convert a pointer value */
-SWIGRUNTIMEINLINE int
-SWIG_R_ConvertPtr(SEXP obj, void **ptr, swig_type_info *ty, int flags) {
-  void *vptr;
-  if (!obj) return SWIG_ERROR;
-  if (obj == R_NilValue) {
-    if (ptr) *ptr = NULL;
-    return SWIG_OK;
-  }
-
-  vptr = R_ExternalPtrAddr(obj);
-  if (ty) {
-    swig_type_info *to = (swig_type_info*) 
-      R_ExternalPtrAddr(R_ExternalPtrTag(obj));
-    if (to == ty) {
-      if (ptr) *ptr = vptr;
-    } else {
-      swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
-      int newmemory = 0;
-      if (ptr) *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
-      assert(!newmemory); /* newmemory handling not yet implemented */
-    }
-  } else {
-      if (ptr) *ptr = vptr;
- }
-  return SWIG_OK;
-}
-
-SWIGRUNTIME swig_module_info *
-SWIG_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
-  static void *type_pointer = (void *)0;
-  return (swig_module_info *) type_pointer;
-}
-
-SWIGRUNTIME void
-SWIG_SetModule(void *v, swig_module_info *swig_module) {
-}
-
-typedef struct {
-  void *pack;
-  swig_type_info *ty;
-  size_t size;
-} RSwigPacked;
-
-/* Create a new packed object */
-
-SWIGRUNTIMEINLINE SEXP RSwigPacked_New(void *ptr, size_t sz,
-		  swig_type_info *ty) {
-  SEXP rptr;
-  RSwigPacked *sobj = 
-  (RSwigPacked*) malloc(sizeof(RSwigPacked));
-  if (sobj) {
-    void *pack = malloc(sz);
-    if (pack) {
-      memcpy(pack, ptr, sz);
-      sobj->pack = pack;
-      sobj->ty   = ty;
-      sobj->size = sz;
-    } else {
-      sobj = 0;
-    }
-  }
-  rptr = R_MakeExternalPtr(sobj, R_NilValue, R_NilValue); 
-  return rptr;
-}
-
-SWIGRUNTIME swig_type_info *
-RSwigPacked_UnpackData(SEXP obj, void *ptr, size_t size)
-{
-    RSwigPacked *sobj = 
-        (RSwigPacked *)R_ExternalPtrAddr(obj);
-    if (sobj->size != size) return 0;
-    memcpy(ptr, sobj->pack, size);
-    return sobj->ty;
-}
-
-SWIGRUNTIMEINLINE SEXP
-SWIG_R_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
-  return ptr ? RSwigPacked_New((void *) ptr, sz, type) : R_NilValue;
-}
-
-/* Convert a packed value value */
-
-SWIGRUNTIME int
-SWIG_R_ConvertPacked(SEXP obj, void *ptr, size_t sz, swig_type_info *ty) {
-  swig_type_info *to = RSwigPacked_UnpackData(obj, ptr, sz);
-  if (!to) return SWIG_ERROR;
-  if (ty) {
-    if (to != ty) {
-      /* check type cast? */
-      swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
-      if (!tc) return SWIG_ERROR;
-    }
-  }
-  return SWIG_OK;
-}  
-
-#ifdef __cplusplus
-#include <exception>
-#define SWIG_exception_noreturn(code, msg) do { throw std::runtime_error(msg); } while(0)
-#else
-#define SWIG_exception_noreturn(code, msg) do { return result; } while(0)
-#endif
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/share/swig/2.0.11/r/rstdcommon.swg b/share/swig/2.0.11/r/rstdcommon.swg
deleted file mode 100644
index b11cf67..0000000
--- a/share/swig/2.0.11/r/rstdcommon.swg
+++ /dev/null
@@ -1,210 +0,0 @@
-%fragment("StdTraits","header",fragment="StdTraitsCommon")
-{
-namespace swig {  
-  /*
-    Traits that provides the from method
-  */
-
-  template <class Type> struct traits_from_ptr {
-    static SWIG_Object from(Type *val, int owner = 0) {
-      return SWIG_NewPointerObj(val, type_info<Type>(), owner);
-    }
-  };
-
-  template <class Type> struct traits_from {
-    static SWIG_Object from(const Type& val) {
-      return traits_from_ptr<Type>::from(new Type(val), 1);
-    }
-  };
-
-  template <class Type> struct traits_from<Type *> {
-    static SWIG_Object from(Type* val) {
-      return traits_from_ptr<Type>::from(val, 0);
-    }
-  };
-
-  template <class Type>
-  inline SWIG_Object from(const Type& val) {
-    return traits_from<Type>::from(val);
-  }
-
-  template <class Type>
-  inline SWIG_Object from_ptr(Type* val, int owner) {
-    return traits_from_ptr<Type>::from(val, owner);
-  }
-
-  /*
-    Traits that provides the asval/as/check method
-  */
-  template <class Type>
-  struct traits_asptr {   
-    static int asptr(SWIG_Object obj, Type **val) {
-      Type *p;
-      int res = SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0);
-      if (SWIG_IsOK(res)) {
-	if (val) *val = p;
-      }
-      return res;
-    }
-  }; 
-
-  template <class Type>
-  inline int asptr(SWIG_Object obj, Type **vptr) {
-    return traits_asptr<Type>::asptr(obj, vptr);
-  }
-
-  template <class Type> 
-  struct traits_asval {
-    static int asval(SWIG_Object obj, Type *val) {
-      if (val) {
-	Type *p = 0;
-	int res = traits_asptr<Type>::asptr(obj, &p);
-	if (!SWIG_IsOK(res)) return res;	
-	if (p) {
-	  typedef typename noconst_traits<Type>::noconst_type noconst_type;
-	  *(const_cast<noconst_type*>(val)) = *p;
-	  if (SWIG_IsNewObj(res)){
-	    %delete(p);
-	    res = SWIG_DelNewMask(res);
-	  }
-	  return res;
-	} else {
-	  return SWIG_ERROR;
-	}
-      } else {
-	return traits_asptr<Type>::asptr(obj, (Type **)(0));
-      }
-    }
-  };
-
-  template <class Type> struct traits_asval<Type*> {
-    static int asval(SWIG_Object obj, Type **val) {
-      if (val) {
-        typedef typename noconst_traits<Type>::noconst_type noconst_type;
-        noconst_type *p = 0;
-        int res = traits_asptr<noconst_type>::asptr(obj,  &p);
-        if (SWIG_IsOK(res)) {
-          *(const_cast<noconst_type**>(val)) = p;
-	}
-	return res;
-      } else {
-	return traits_asptr<Type>::asptr(obj, (Type **)(0));
-      }
-    }
-  };
-  
-  template <class Type>
-  inline int asval(SWIG_Object obj, Type *val) {
-    return traits_asval<Type>::asval(obj, val);
-  }
-
-  template <class Type> 
-  struct traits_as<Type, value_category> {
-    static Type as(SWIG_Object obj, bool throw_error) {
-      Type v;
-      int res = asval(obj, &v);
-      if (!obj || !SWIG_IsOK(res)) {
-	if (throw_error)
-          throw std::invalid_argument("bad type");
-      }
-      return v;
-    }
-  };
-
-  template <class Type> 
-  struct traits_as<Type, pointer_category> {
-    static Type as(SWIG_Object obj, bool throw_error) {
-      Type *v = 0;      
-      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
-      if (SWIG_IsOK(res) && v) {
-	if (SWIG_IsNewObj(res)) {
-	  Type r(*v);
-	  %delete(v);
-	  return r;
-	} else {
-	  return *v;
-	}
-      } else {
-	// Uninitialized return value, no Type() constructor required.
-	static Type *v_def = (Type*) malloc(sizeof(Type));
-	if (throw_error)
-          throw std::invalid_argument("bad type");
-	memset(v_def,0,sizeof(Type));
-	return *v_def;
-      }
-    }
-  };
-
-  template <class Type> 
-  struct traits_as<Type*, pointer_category> {
-    static Type* as(SWIG_Object obj, bool throw_error) {
-      Type *v = 0;      
-      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
-      if (SWIG_IsOK(res)) {
-	return v;
-      } else {
-	if (throw_error)
-          throw std::invalid_argument("bad type");
-	return 0;
-      }
-    }
-  };
-    
-  template <class Type>
-  inline Type as(SWIG_Object obj, bool te = false) {
-    return traits_as<Type, typename traits<Type>::category>::as(obj, te);
-  }
-
-  template <class Type> 
-  struct traits_check<Type, value_category> {
-    static bool check(SWIG_Object obj) {
-      int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
-      return SWIG_IsOK(res) ? true : false;
-    }
-  };
-
-  template <class Type> 
-  struct traits_check<Type, pointer_category> {
-    static bool check(SWIG_Object obj) {
-      int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
-      return SWIG_IsOK(res) ? true : false;
-    }
-  };
-
-  template <class Type>
-  inline bool check(SWIG_Object obj) {
-    return traits_check<Type, typename traits<Type>::category>::check(obj);
-  }
-}
-}
-
-%define %specialize_std_container(Type,Check,As,From)
-%{
-namespace swig {
-  template <>  struct traits_asval<Type > {   
-    typedef Type value_type;
-    static int asval(SWIG_Object obj, value_type *val) {
-      if (Check(obj)) {
-	if (val) *val = As(obj);
-	return SWIG_OK;
-      }
-      return SWIG_ERROR;
-    }
-  };
-  template <>  struct traits_from<Type > {
-    typedef Type value_type;
-    static SWIG_Object from(const value_type& val) {
-      return From(val);
-    }
-  };
-
-  template <> 
-  struct traits_check<Type, value_category> {
-    static int check(SWIG_Object obj) {
-      int res = Check(obj);
-      return obj && res ? res : 0;
-    }
-  };
-}
-%}
-%enddef
diff --git a/share/swig/2.0.11/r/rtype.swg b/share/swig/2.0.11/r/rtype.swg
deleted file mode 100644
index b86a618..0000000
--- a/share/swig/2.0.11/r/rtype.swg
+++ /dev/null
@@ -1,316 +0,0 @@
-
-/* These map the primitive C types to the appropriate R type
-   for use in class representations. 
- */
-
-%typemap("rtype") int, int *, int &      "integer";
-%typemap("rtype") long, long *, long &      "integer";
-%typemap("rtype") float, float*, float & "numeric";
-%typemap("rtype") double, double*, double & "numeric";
-%typemap("rtype") char *, char ** "character";
-%typemap("rtype") char            "character";
-%typemap("rtype") string, string *, string & "character";
-%typemap("rtype") std::string, std::string *, std::string & "character";
-%typemap("rtype") bool, bool *    "logical";
-%typemap("rtype") enum SWIGTYPE   "character";
-%typemap("rtype") enum SWIGTYPE *   "character";
-%typemap("rtype") enum SWIGTYPE *const   "character";
-%typemap("rtype") enum SWIGTYPE &  "character";
-%typemap("rtype") SWIGTYPE * "$R_class";
-%typemap("rtype") SWIGTYPE *const "$R_class";
-%typemap("rtype") SWIGTYPE & "$R_class";
-%typemap("rtype") SWIGTYPE "$&R_class";
-
-%typemap("rtypecheck") int, int &, long, long &
-  %{ (is.integer($arg) || is.numeric($arg)) && length($arg) == 1 %}
-%typemap("rtypecheck") int *, long *
-  %{ is.integer($arg) || is.numeric($arg) %}
-
-
-%typemap("rtypecheck") float, double
-  %{ is.numeric($arg) && length($arg) == 1 %}
-%typemap("rtypecheck") float *, double *
-  %{ is.numeric($arg) %}
-
-%typemap("rtypecheck") bool, bool &
-  %{ is.logical($arg) && length($arg) == 1 %}
-%typemap("rtypecheck") bool *
-  %{ is.logical($arg) %}
-
-/*
-  Set up type checks to insure overloading precedence.
-  We would like non pointer items to shadow pointer items, so that 
-  they get called if length = 1
-*/
-
-%typecheck(SWIG_TYPECHECK_BOOL) bool {}
-%typecheck(SWIG_TYPECHECK_UINT32) unsigned int {}
-%typecheck(SWIG_TYPECHECK_INTEGER) int {}
-%typecheck(SWIG_TYPECHECK_FLOAT) float {}
-%typecheck(SWIG_TYPECHECK_DOUBLE) double {}
-
-%typecheck(SWIG_TYPECHECK_BOOL_PTR) bool * {}
-%typecheck(SWIG_TYPECHECK_INT32_PTR) int * {}
-%typecheck(SWIG_TYPECHECK_FLOAT_PTR) float * {}
-%typecheck(SWIG_TYPECHECK_DOUBLE_PTR) double * {}
-%typecheck(SWIG_TYPECHECK_CHAR_PTR) char * {}
-
-%typecheck(SWIG_TYPECHECK_INT32_ARRAY) int[ANY] {}
-%typecheck(SWIG_TYPECHECK_FLOAT_ARRAY) float[ANY] {}
-%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY) double [ANY] {}
-
-/* Have to be careful that as(x, "numeric") is different from as.numeric(x).  
-   The latter makes a REALSXP, whereas the former leaves an INTSXP as an
-   INTSXP.
-*/
-
-/* Force coercion of integer, since by default R sets all constants to
-   numeric, which means that you can't directly call a function with an 
-   integer using an R numercal literal */
-
-%typemap(scoercein) int, int *, int &
-  %{  $input = as.integer($input);     %}
-%typemap(scoercein) long, long *, long &
-  %{  $input = as.integer($input);     %}
-%typemap(scoercein) float, float*, float &,
-  double, double *, double &
-  %{ %}
-%typemap(scoercein) char, char *, char &
-  %{  $input = as($input, "character");     %}
-%typemap(scoercein) string, string *, string &
-  %{  $input = as($input, "character");     %}
-%typemap(scoercein) std::string, std::string *, std::string &
-  %{  $input = as($input, "character");     %}
-%typemap(scoercein) enum SWIGTYPE 
-  %{  $input = enumToInteger($input, "$R_class"); %}
-%typemap(scoercein) enum SWIGTYPE &
-  %{  $input = enumToInteger($input, "$R_class"); %}
-%typemap(scoercein) enum SWIGTYPE *
-  %{  $input = enumToInteger($input, "$R_class"); %}
-%typemap(scoercein) enum SWIGTYPE *const
-  %{  $input = enumToInteger($input, "$R_class"); %}
-
-%typemap(scoercein) SWIGTYPE, SWIGTYPE *, SWIGTYPE *const, SWIGTYPE &  
- %{ if (inherits($input, "ExternalReference")) $input = slot($input,"ref") %}
-
-/*
-%typemap(scoercein) SWIGTYPE *, SWIGTYPE *const
-  %{ $input = coerceIfNotSubclass($input, "$R_class") %}
-
-%typemap(scoercein) SWIGTYPE & 
-  %{ $input = coerceIfNotSubclass($input, "$R_class") %}
-
-%typemap(scoercein) SWIGTYPE  
-  %{ $input = coerceIfNotSubclass($input, "$&R_class") %}
-*/
-
-%typemap(scoercein) SWIGTYPE[ANY]  
- %{
-    if(is.list($input))
-      assert(all(sapply($input, class) == "$R_class"));
- %}
-
-
-/* **************************************************************** */
-
-%typemap(scoercein) bool, bool *, bool & 
-		    "$input = as.logical($input);";
-%typemap(scoercein) int, 
-                    int *, 
-		    int &,
-		    long,
-		    long *,
-		    long &
-  "$input = as.integer($input);";
-
-%typemap(scoercein) char *, string, std::string,
-string &, std::string &
-%{  $input = as($input, "character"); %}
-
-%typemap(scoerceout) enum SWIGTYPE 
-  %{  $result = enumFromInteger($result, "$R_class"); %}
-
-%typemap(scoerceout) enum SWIGTYPE &
-  %{  $result = enumFromInteger($result, "$R_class"); %}
-
-%typemap(scoerceout) enum SWIGTYPE *
-  %{  $result = enumToInteger($result, "$R_class"); %}
-
-%typemap(scoerceout) enum SWIGTYPE *const
-  %{  $result = enumToInteger($result, "$R_class"); %}
-
-#%typemap(scoerceout) SWIGTYPE 
-#  %{ class($result) <- "$&R_class"; %}
-
-#%typemap(scoerceout) SWIGTYPE & 
-#  %{ class($result) <- "$R_class"; %}
-
-#%typemap(scoerceout) SWIGTYPE * 
-#  %{ class($result) <- "$R_class"; %}
-
-#%typemap(scoerceout) SWIGTYPE *const
-#  %{ class($result) <- "$R_class"; %}
-
- %typemap(scoerceout) SEXP %{ %}
-
- %typemap(scoerceout) SWIGTYPE 
- %{ $result <- new("$&R_class", ref=$result); %}
- 
- %typemap(scoerceout) SWIGTYPE & 
- %{ $result <- new("$R_class", ref=$result) ; %}
- 
- %typemap(scoerceout) SWIGTYPE * 
- %{ $result <- new("$R_class", ref=$result) ; %}
- 
- %typemap(scoerceout) SWIGTYPE *const
- %{ $result <- new("$R_class", ref=$result) ; %}
-
-
-/* Override the SWIGTYPE * above. */
-%typemap(scoerceout) char,
-		     char *,
-		     char &,
-                     float,
-		     double,
-		     float*,
-		     double*,
-		     float &,
-		     double &,
-                     int,
-		     int &,
-		     long,
-		     long &,
-                     bool,
-		     bool &,
-		     string,
-		     std::string,
-		     string &,
-		     std::string &, 
-		     void,
-		     signed int,
-		     signed int &,		     
-		     unsigned int,
-		     unsigned int &,		     
-		     short,
-		     short &,		     
-		     unsigned short,
-		     unsigned short &,		     
-		     long long,
-		     signed long long,
-		     signed long long &,		     
-		     unsigned long long,
-		     unsigned long long &,		     
-		     signed long,
-		     signed long &,		     
-		     unsigned long,
-		     unsigned long &,
-		     signed char,
-		     signed char &,
-		     unsigned char,
-		     unsigned char &
- %{    %}
-
-%apply int {size_t,
-std::size_t,
-ptrdiff_t,
-std::ptrdiff_t,
-signed int,
-unsigned int,
-short,
-unsigned short,
-signed char,
-unsigned char}
-
-%apply int* {size_t[],
-std::size_t[],
-ptrdiff_t[],
-std::ptrdiff_t[],
-signed int[],
-unsigned int[],
-short[],
-unsigned short[],
-signed char[],
-unsigned char[]}
-
-%apply int* {size_t[ANY],
-std::size_t[ANY],
-ptrdiff_t[ANY],
-std::ptrdiff_t[ANY],
-signed int[ANY],
-unsigned int[ANY],
-short[ANY],
-unsigned short[ANY],
-signed char[ANY],
-unsigned char[ANY]}
-
-%apply int* {size_t*,
-std::size_t*,
-ptrdiff_t*,
-std::ptrdiff_t*,
-signed int*,
-unsigned int*,
-short*,
-unsigned short*,
-signed char*,
-unsigned char*}
-
-%apply long {
-       long long,
-       signed long long,
-       unsigned long long,
-       signed long,
-       unsigned long}
-
-%apply long* {
-       long long*,
-       signed long long*,
-       unsigned long long*,
-       signed long*,
-       unsigned long*,
-       long long[],
-       signed long long[],
-       unsigned long long[],
-       signed long[],
-       unsigned long[],
-       long long[ANY],
-       signed long long[ANY],
-       unsigned long long[ANY],
-       signed long[ANY],
-       unsigned long[ANY]}
-
-%apply float* {
-       float[],
-       float[ANY]
-}
-%apply double * {
-       double[],
-       double[ANY]
-}
-
-%apply bool* {
-       bool[],
-       bool[ANY]
-}
-
-#if 0
- Just examining the values for a SWIGTYPE.
-
-%typemap(scoerceout) SWIGTYPE  %{
-
-  name = $1_name
-  type = $1_type
-  ltype = $1_ltype
-
-  mangle = $1_mangle
-  descriptor = $1_descriptor
-
-  pointer type = $*1_type
-  pointer ltype = $*1_ltype
-
-  pointer descriptor = $*1_descriptor
-  basetype = $*_basetype
-
-%}
-#endif
-
-
diff --git a/share/swig/2.0.11/r/srun.swg b/share/swig/2.0.11/r/srun.swg
deleted file mode 100644
index 71a508d..0000000
--- a/share/swig/2.0.11/r/srun.swg
+++ /dev/null
@@ -1,150 +0,0 @@
-#                         srun.swg                            #
-#
-# This is the basic code that is needed at run time within R to
-# provide and define the relevant classes.  It is included
-# automatically in the generated code by copying the contents of
-# srun.swg into the newly created binding code.
-
-
-# This could be provided as a separate run-time library but this
-# approach allows the code to to be included directly into the
-# generated bindings and so removes the need to have and install an
-# additional library.  We may however end up with multiple copies of
-# this and some confusion at run-time as to which class to use. This
-# is an issue when we use NAMESPACES as we may need to export certain
-# classes.
-
-######################################################################
-
-if(length(getClassDef("RSWIGStruct")) == 0) 
-  setClass("RSWIGStruct", representation("VIRTUAL"))
-
-
-
-if(length(getClassDef("ExternalReference")) == 0) 
-# Should be virtual but this means it loses its slots currently
-#representation("VIRTUAL")
-  setClass("ExternalReference", representation( ref = "externalptr"))
-
-
-
-if(length(getClassDef("NativeRoutinePointer")) == 0) 
-  setClass("NativeRoutinePointer", 
-              representation(parameterTypes = "character",
-                             returnType = "character",
-                             "VIRTUAL"), 
-              contains = "ExternalReference")
-
-if(length(getClassDef("CRoutinePointer")) == 0) 
-  setClass("CRoutinePointer", contains = "NativeRoutinePointer")
-
-
-if(length(getClassDef("EnumerationValue")) == 0) 
-  setClass("EnumerationValue", contains = "integer")
-
-
-if(!isGeneric("copyToR")) 
- setGeneric("copyToR",
-            function(value, obj = new(gsub("Ref$", "", class(value)))) 
-               standardGeneric("copyToR"
-           ))
-
-setGeneric("delete", function(obj) standardGeneric("delete"))
-
-
-SWIG_createNewRef = 
-function(className, ..., append = TRUE)
-{
-  f = get(paste("new", className, sep = "_"), mode = "function")
-
-  f(...)
-}
-
-if(!isGeneric("copyToC")) 
- setGeneric("copyToC", 
-             function(value, obj = RSWIG_createNewRef(class(value)))
-              standardGeneric("copyToC"
-            ))
-
-
-# 
-defineEnumeration =
-function(name, .values, where = topenv(parent.frame()), suffix = "Value")
-{
-   # Mirror the class definitions via the E analogous to .__C__
-  defName = paste(".__E__", name, sep = "")
-  assign(defName,  .values,  envir = where)
-
-  if(nchar(suffix))
-    name = paste(name, suffix, sep = "")
-
-  setClass(name, contains = "EnumerationValue", where = where)
-}
-
-enumToInteger <- function(name,type)
-{
-   if (is.character(name)) {
-   ans <- as.integer(get(paste(".__E__", type, sep = ""))[name])
-   if (is.na(ans)) {warning("enum not found ", name, " ", type)}
-   ans
-   } 
-}
-
-enumFromInteger =
-function(i,type)
-{
-  itemlist <- get(paste(".__E__", type, sep=""))
-  names(itemlist)[match(i, itemlist)]
-}
-
-coerceIfNotSubclass =
-function(obj, type) 
-{
-    if(!is(obj, type)) {as(obj, type)} else obj
-}
-
-
-setClass("SWIGArray", representation(dims = "integer"), contains = "ExternalReference")
-
-setMethod("length", "SWIGArray", function(x) x@dims[1])
-
-
-defineEnumeration("SCopyReferences",
-                   .values = c( "FALSE" = 0, "TRUE" = 1, "DEEP" = 2))
-
-assert = 
-function(condition, message = "")
-{
-  if(!condition)
-    stop(message)
-
-  TRUE
-}
-
-
-if(FALSE) {
-print.SWIGFunction =
-function(x, ...)
- {
- }
-}
-
-
-#######################################################################
-
-R_SWIG_getCallbackFunctionStack =
-function()
-{
-    # No PACKAGE argument as we don't know what the DLL is.
-  .Call("R_SWIG_debug_getCallbackFunctionData")
-}
-
-R_SWIG_addCallbackFunctionStack =
-function(fun, userData = NULL)
-{
-    # No PACKAGE argument as we don't know what the DLL is.
-  .Call("R_SWIG_R_pushCallbackFunctionData", fun, userData)
-}
-
-
-#######################################################################
\ No newline at end of file
diff --git a/share/swig/2.0.11/r/std_common.i b/share/swig/2.0.11/r/std_common.i
deleted file mode 100644
index 8e97521..0000000
--- a/share/swig/2.0.11/r/std_common.i
+++ /dev/null
@@ -1,73 +0,0 @@
-%include <rstdcommon.swg>
-
-
-/*
-  Generate the traits for a 'primitive' type, such as 'double',
-  for which the SWIG_AsVal and SWIG_From methods are already defined.
-*/
-
-%define %traits_ptypen(Type...)
-  %fragment(SWIG_Traits_frag(Type),"header",
-	    fragment=SWIG_AsVal_frag(Type),
-	    fragment=SWIG_From_frag(Type),
-	    fragment="StdTraits") {
-namespace swig {
-  template <> struct traits<Type > {
-    typedef value_category category;
-    static const char* type_name() { return  #Type; }
-  };  
-  template <>  struct traits_asval<Type > {   
-    typedef Type value_type;
-    static int asval(SEXP obj, value_type *val) { 
-      return SWIG_AsVal(Type)(obj, val);
-    }
-  };
-  template <>  struct traits_from<Type > {
-    typedef Type value_type;
-    static SEXP from(const value_type& val) {
-      return SWIG_From(Type)(val);
-    }
-  };
-}
-}
-%enddef
-
-/* Traits for enums. This is bit of a sneaky trick needed because a generic template specialization of enums
-   is not possible (unless using template meta-programming which SWIG doesn't support because of the explicit
-   instantiations required using %template). The STL containers define the 'front' method and the typemap
-   below is used whenever the front method is wrapped returning an enum. This typemap simply picks up the
-   standard enum typemap, but additionally drags in a fragment containing the traits_asval and traits_from
-   required in the generated code for enums. */
-
-%define %traits_enum(Type...)
-  %fragment("SWIG_Traits_enum_"{Type},"header",
-	    fragment=SWIG_AsVal_frag(int),
-	    fragment=SWIG_From_frag(int),
-	    fragment="StdTraits") {
-namespace swig {
-  template <>  struct traits_asval<Type > {   
-    typedef Type value_type;
-    static int asval(SEXP obj, value_type *val) { 
-      return SWIG_AsVal(int)(obj, (int *)val);
-    }
-  };
-  template <>  struct traits_from<Type > {
-    typedef Type value_type;
-    static SEXP from(const value_type& val) {
-      return SWIG_From(int)((int)val);
-    }
-  };
-}
-}
-%typemap(out, fragment="SWIG_Traits_enum_"{Type}) const enum SWIGTYPE& front %{$typemap(out, const enum SWIGTYPE&)%}
-%enddef
-
-
-%include <std/std_common.i>
-
-//
-// Generates the traits for all the known primitive
-// C++ types (int, double, ...)
-//
-%apply_cpptypes(%traits_ptypen);
-
diff --git a/share/swig/2.0.11/r/std_vector.i b/share/swig/2.0.11/r/std_vector.i
deleted file mode 100644
index 836c95b..0000000
--- a/share/swig/2.0.11/r/std_vector.i
+++ /dev/null
@@ -1,608 +0,0 @@
-// R specific swig components
-/*
-  Vectors
-*/
-
-%fragment("StdVectorTraits","header",fragment="StdSequenceTraits")
-%{
-  namespace swig {
-    // vectors of doubles
-    template <>
-      struct traits_from_ptr<std::vector<double> > {
-      static SEXP from (std::vector<double > *val, int owner = 0) {
-        SEXP result;
-        PROTECT(result = Rf_allocVector(REALSXP, val->size()));
-        for (unsigned pos = 0; pos < val->size(); pos++)
-          {
-            NUMERIC_POINTER(result)[pos] = ((*val)[pos]);
-          }
-        UNPROTECT(1);
-        return(result);
-      }
-    };
-    // vectors of floats
-    template <>
-      struct traits_from_ptr<std::vector<float> > {
-      static SEXP from (std::vector<float > *val, int owner = 0) {
-        SEXP result;
-        PROTECT(result = Rf_allocVector(REALSXP, val->size()));
-        for (unsigned pos = 0; pos < val->size(); pos++)
-          {
-            NUMERIC_POINTER(result)[pos] = ((*val)[pos]);
-          }
-        UNPROTECT(1);
-        return(result);
-      }
-    };
-    // vectors of unsigned int
-    template <>
-      struct traits_from_ptr<std::vector<unsigned int> > {
-      static SEXP from (std::vector<unsigned int > *val, int owner = 0) {
-        SEXP result;
-        PROTECT(result = Rf_allocVector(INTSXP, val->size()));
-        for (unsigned pos = 0; pos < val->size(); pos++)
-          {
-            INTEGER_POINTER(result)[pos] = ((*val)[pos]);
-          }
-        UNPROTECT(1);
-        return(result);
-      }
-    };
-    // vectors of int
-    template <>
-      struct traits_from_ptr<std::vector<int> > {
-      static SEXP from (std::vector<int > *val, int owner = 0) {
-        SEXP result;
-        PROTECT(result = Rf_allocVector(INTSXP, val->size()));
-        for (unsigned pos = 0; pos < val->size(); pos++)
-          {
-            INTEGER_POINTER(result)[pos] = ((*val)[pos]);
-          }
-        UNPROTECT(1);
-        return(result);
-      }
-    };
-
-    // vectors of bool
-    template <>
-      struct traits_from_ptr<std::vector<bool> > {
-      static SEXP from (std::vector<bool> *val, int owner = 0) {
-        SEXP result;
-        PROTECT(result = Rf_allocVector(LGLSXP, val->size()));
-        for (unsigned pos = 0; pos < val->size(); pos++)
-          {
-            LOGICAL_POINTER(result)[pos] = ((*val)[pos]);
-          }
-        UNPROTECT(1);
-        return(result);
-        //return SWIG_R_NewPointerObj(val, type_info< std::vector<T > >(), owner);
-      }
-    };
-    // vectors of strings
-    template <>
-      struct traits_from_ptr<std::vector<std::basic_string<char> > > {
-      static SEXP from (std::vector<std::basic_string<char> > *val, int owner = 0) {
-        SEXP result;
-         PROTECT(result = Rf_allocVector(STRSXP, val->size()));
-         for (unsigned pos = 0; pos < val->size(); pos++)
-           {
-             CHARACTER_POINTER(result)[pos] = Rf_mkChar(((*val)[pos]).c_str());
-           }
-        UNPROTECT(1);
-        return(result);
-        //return SWIG_R_NewPointerObj(val, type_info< std::vector<T > >(), owner);
-      }
-    };
-
-    // catch all that does everything with vectors
-    template <typename T>
-      struct traits_from_ptr< std::vector< T > > {
-      static SEXP from (std::vector< T > *val, int owner = 0) {
-        return SWIG_R_NewPointerObj(val, type_info< std::vector< T >  >(), owner);
-      }
-    };
-
-    template <>
-  struct traits_asptr < std::vector<double> > {
-    static int asptr(SEXP obj, std::vector<double> **val) {
-      std::vector<double> *p;
-      // not sure how to check the size of the SEXP obj is correct
-      unsigned int sexpsz = Rf_length(obj);
-      p = new std::vector<double>(sexpsz);
-      double *S = NUMERIC_POINTER(obj);
-      for (unsigned pos = 0; pos < p->size(); pos++)
-        {
-          (*p)[pos] = static_cast<double>(S[pos]);
-        }
-      int res = SWIG_OK;
-      if (SWIG_IsOK(res)) {
-        if (val) *val = p;
-      }
-      return res;
-    }
-  };
-
-    template <>
-  struct traits_asptr < std::vector<float> > {
-    static int asptr(SEXP obj, std::vector<float> **val) {
-      std::vector<float> *p;
-      // not sure how to check the size of the SEXP obj is correct
-      unsigned int sexpsz = Rf_length(obj);
-      p = new std::vector<float>(sexpsz);
-      double *S = NUMERIC_POINTER(obj);
-      for (unsigned pos = 0; pos < p->size(); pos++)
-        {
-          (*p)[pos] = static_cast<double>(S[pos]);
-        }
-      int res = SWIG_OK;
-      if (SWIG_IsOK(res)) {
-        if (val) *val = p;
-      }
-      return res;
-    }
-  };
-
-    template <>
-  struct traits_asptr < std::vector<unsigned int> > {
-    static int asptr(SEXP obj, std::vector<unsigned int> **val) {
-      std::vector<unsigned int> *p;
-      unsigned int sexpsz = Rf_length(obj);
-      p = new std::vector<unsigned int>(sexpsz);
-      SEXP coerced;
-      PROTECT(coerced = Rf_coerceVector(obj, INTSXP));
-      int *S = INTEGER_POINTER(coerced);
-      for (unsigned pos = 0; pos < p->size(); pos++)
-        {
-          (*p)[pos] = static_cast<unsigned int>(S[pos]);
-        }
-      int res = SWIG_OK;
-      if (SWIG_IsOK(res)) {
-        if (val) *val = p;
-      }
-      UNPROTECT(1);
-      return res;
-    }
-  };
-
-    template <>
-  struct traits_asptr < std::vector<int> > {
-    static int asptr(SEXP obj, std::vector<int> **val) {
-      std::vector<int> *p;
-      // not sure how to check the size of the SEXP obj is correct
-      int sexpsz = Rf_length(obj);
-      p = new std::vector<int>(sexpsz);
-      SEXP coerced;
-      PROTECT(coerced = Rf_coerceVector(obj, INTSXP));
-      int *S = INTEGER_POINTER(coerced);
-      for (unsigned pos = 0; pos < p->size(); pos++)
-        {
-          (*p)[pos] = static_cast<int>(S[pos]);
-        }
-      int res = SWIG_OK;
-      if (SWIG_IsOK(res)) {
-        if (val) *val = p;
-      }
-      UNPROTECT(1);
-      return res;
-    }
-  };
-
-    template <>
-  struct traits_asptr < std::vector<bool> > {
-    static int asptr(SEXP obj, std::vector<bool> **val) {
-      std::vector<bool> *p;
-      // not sure how to check the size of the SEXP obj is correct
-      int sexpsz = Rf_length(obj);
-      p = new std::vector<bool>(sexpsz);
-      SEXP coerced;
-      PROTECT(coerced = Rf_coerceVector(obj, LGLSXP));
-      int *S = LOGICAL_POINTER(coerced);
-      for (unsigned pos = 0; pos < p->size(); pos++)
-        {
-          (*p)[pos] = static_cast<bool>(S[pos]);
-        }
-      int res = SWIG_OK;
-      if (SWIG_IsOK(res)) {
-        if (val) *val = p;
-      }
-      UNPROTECT(1);
-      return res;
-    }
-  };
-
-    // catchall for R to vector conversion
-  template <typename T>
-  struct traits_asptr < std::vector<T> > {
-    static int asptr(SEXP obj, std::vector<T> **val) {
-      std::vector<T> *p;
-      Rprintf("my asptr\n");
-     int res = SWIG_R_ConvertPtr(obj, (void**)&p, type_info< std::vector<T> >(), 0);
-      if (SWIG_IsOK(res)) {
-        if (val) *val = p;
-      }
-      return res;
-    }
-  };
-
-  // now for vectors of vectors. These will be represented as lists of vectors on the
-  // catch all that does everything with vectors
-  template <>
-    struct traits_from_ptr<std::vector<std::vector<unsigned int> > > {
-      static SEXP from (std::vector< std::vector<unsigned int > > *val, int owner = 0) {
-        SEXP result;
-        // allocate the R list
-        PROTECT(result = Rf_allocVector(VECSXP, val->size()));
-        for (unsigned pos = 0; pos < val->size(); pos++)
-          {
-            // allocate the R vector
-            SET_VECTOR_ELT(result, pos, Rf_allocVector(INTSXP, val->at(pos).size()));
-            // Fill the R vector
-            for (unsigned vpos = 0; vpos < val->at(pos).size(); ++vpos)
-              {
-                INTEGER_POINTER(VECTOR_ELT(result, pos))[vpos] = static_cast<int>(val->at(pos).at(vpos));
-              }
-          }
-        UNPROTECT(1);
-        return(result);
-      }
-    };
-
-  template <>
-    struct traits_from_ptr<std::vector<std::vector<int> > > {
-      static SEXP from (std::vector< std::vector<int > > *val, int owner = 0) {
-        SEXP result;
-        // allocate the R list
-        PROTECT(result = Rf_allocVector(VECSXP, val->size()));
-        for (unsigned pos = 0; pos < val->size(); pos++)
-          {
-            // allocate the R vector
-            SET_VECTOR_ELT(result, pos, Rf_allocVector(INTSXP, val->at(pos).size()));
-            // Fill the R vector
-            for (unsigned vpos = 0; vpos < val->at(pos).size(); ++vpos)
-              {
-                INTEGER_POINTER(VECTOR_ELT(result, pos))[vpos] = static_cast<int>(val->at(pos).at(vpos));
-              }
-          }
-        UNPROTECT(1);
-        return(result);
-      }
-    };
-
-  template <>
-    struct traits_from_ptr<std::vector<std::vector<float> > > {
-      static SEXP from (std::vector< std::vector<float > > *val, int owner = 0) {
-        SEXP result;
-        // allocate the R list
-        PROTECT(result = Rf_allocVector(VECSXP, val->size()));
-        for (unsigned pos = 0; pos < val->size(); pos++)
-          {
-            // allocate the R vector
-            SET_VECTOR_ELT(result, pos, Rf_allocVector(REALSXP, val->at(pos).size()));
-            // Fill the R vector
-            for (unsigned vpos = 0; vpos < val->at(pos).size(); ++vpos)
-              {
-                NUMERIC_POINTER(VECTOR_ELT(result, pos))[vpos] = static_cast<double>(val->at(pos).at(vpos));
-              }
-          }
-        UNPROTECT(1);
-        return(result);
-      }
-    };
-
-  template <>
-    struct traits_from_ptr<std::vector<std::vector<double> > > {
-      static SEXP from (std::vector< std::vector<double > > *val, int owner = 0) {
-        SEXP result;
-        // allocate the R list
-        PROTECT(result = Rf_allocVector(VECSXP, val->size()));
-        for (unsigned pos = 0; pos < val->size(); pos++)
-          {
-            // allocate the R vector
-            SET_VECTOR_ELT(result, pos, Rf_allocVector(REALSXP, val->at(pos).size()));
-            // Fill the R vector
-            for (unsigned vpos = 0; vpos < val->at(pos).size(); ++vpos)
-              {
-                NUMERIC_POINTER(VECTOR_ELT(result, pos))[vpos] = static_cast<double>(val->at(pos).at(vpos));
-              }
-          }
-        UNPROTECT(1);
-        return(result);
-      }
-    };
-
-  template <>
-    struct traits_from_ptr<std::vector<std::vector<bool> > > {
-      static SEXP from (std::vector< std::vector<bool> > *val, int owner = 0) {
-        SEXP result;
-        // allocate the R list
-        PROTECT(result = Rf_allocVector(VECSXP, val->size()));
-        for (unsigned pos = 0; pos < val->size(); pos++)
-          {
-            // allocate the R vector
-            SET_VECTOR_ELT(result, pos, Rf_allocVector(LGLSXP, val->at(pos).size()));
-            // Fill the R vector
-            for (unsigned vpos = 0; vpos < val->at(pos).size(); ++vpos)
-              {
-                LOGICAL_POINTER(VECTOR_ELT(result, pos))[vpos] = (val->at(pos).at(vpos));
-              }
-          }
-        UNPROTECT(1);
-        return(result);
-      }
-    };
-
-  template <typename T>
-    struct traits_from_ptr< std::vector < std::vector< T > > > {
-    static SEXP from (std::vector < std::vector< T > > *val, int owner = 0) {
-      return SWIG_R_NewPointerObj(val, type_info< std::vector < std::vector< T > > >(), owner);
-    }
-  };
-
-  // R side
-  template <>
-    struct traits_asptr < std::vector< std::vector<unsigned int> > > {
-    static int asptr(SEXP obj, std::vector< std::vector<unsigned int> > **val) {
-      std::vector <std::vector<unsigned int> > *p;
-      // this is the length of the list
-      unsigned int sexpsz = Rf_length(obj);
-      p = new std::vector< std::vector<unsigned int> > (sexpsz);
-
-      for (unsigned listpos = 0; listpos < sexpsz; ++listpos)
-        {
-          unsigned vecsize = Rf_length(VECTOR_ELT(obj, listpos));
-          for (unsigned vpos = 0; vpos < vecsize; ++vpos)
-            {
-              (*p)[listpos].push_back(static_cast<int>(INTEGER_POINTER(VECTOR_ELT(obj, listpos))[vpos]));
-            }
-        }
-
-      int res = SWIG_OK;
-
-      if (SWIG_IsOK(res)) {
-        if (val) *val = p;
-      }
-      return res;
-    }
-  };
-
-  template <>
-    struct traits_asptr < std::vector< std::vector< int> > > {
-    static int asptr(SEXP obj, std::vector< std::vector< int> > **val) {
-      std::vector <std::vector< int> > *p;
-      // this is the length of the list
-      unsigned int sexpsz = Rf_length(obj);
-      p = new std::vector< std::vector< int> > (sexpsz);
-
-      for (unsigned listpos = 0; listpos < sexpsz; ++listpos)
-        {
-          unsigned vecsize = Rf_length(VECTOR_ELT(obj, listpos));
-          for (unsigned vpos = 0; vpos < vecsize; ++vpos)
-            {
-              (*p)[listpos].push_back(static_cast<int>(INTEGER_POINTER(VECTOR_ELT(obj, listpos))[vpos]));
-            }
-        }
-
-      int res = SWIG_OK;
-
-      if (SWIG_IsOK(res)) {
-        if (val) *val = p;
-      }
-      return res;
-    }
-  };
-
-  template <>
-    struct traits_asptr < std::vector< std::vector< float> > > {
-    static int asptr(SEXP obj, std::vector< std::vector< float> > **val) {
-      std::vector <std::vector< float> > *p;
-      // this is the length of the list
-      unsigned int sexpsz = Rf_length(obj);
-      p = new std::vector< std::vector< float> > (sexpsz);
-
-      for (unsigned listpos = 0; listpos < sexpsz; ++listpos)
-        {
-          unsigned vecsize = Rf_length(VECTOR_ELT(obj, listpos));
-          for (unsigned vpos = 0; vpos < vecsize; ++vpos)
-            {
-              (*p)[listpos].push_back(static_cast<float>(NUMERIC_POINTER(VECTOR_ELT(obj, listpos))[vpos]));
-            }
-        }
-
-      int res = SWIG_OK;
-
-      if (SWIG_IsOK(res)) {
-        if (val) *val = p;
-      }
-      return res;
-    }
-  };
-
-  template <>
-    struct traits_asptr < std::vector< std::vector< double> > > {
-    static int asptr(SEXP obj, std::vector< std::vector< double> > **val) {
-      std::vector <std::vector< double> > *p;
-      // this is the length of the list
-      unsigned int sexpsz = Rf_length(obj);
-      p = new std::vector< std::vector< double> > (sexpsz);
-
-      for (unsigned listpos = 0; listpos < sexpsz; ++listpos)
-        {
-          unsigned vecsize = Rf_length(VECTOR_ELT(obj, listpos));
-          for (unsigned vpos = 0; vpos < vecsize; ++vpos)
-            {
-              (*p)[listpos].push_back(static_cast<double>(NUMERIC_POINTER(VECTOR_ELT(obj, listpos))[vpos]));
-            }
-        }
-
-      int res = SWIG_OK;
-
-      if (SWIG_IsOK(res)) {
-        if (val) *val = p;
-      }
-      return res;
-    }
-  };
-
-  template <>
-    struct traits_asptr < std::vector< std::vector< bool > > > {
-    static int asptr(SEXP obj, std::vector< std::vector< bool> > **val) {
-      std::vector <std::vector< bool > > *p;
-      // this is the length of the list
-      unsigned int sexpsz = Rf_length(obj);
-      p = new std::vector< std::vector< bool > > (sexpsz);
-
-      for (unsigned listpos = 0; listpos < sexpsz; ++listpos)
-        {
-          unsigned vecsize = Rf_length(VECTOR_ELT(obj, listpos));
-          for (unsigned vpos = 0; vpos < vecsize; ++vpos)
-            {
-              (*p)[listpos].push_back(static_cast<bool>(LOGICAL_POINTER(VECTOR_ELT(obj, listpos))[vpos]));
-            }
-        }
-
-      int res = SWIG_OK;
-
-      if (SWIG_IsOK(res)) {
-        if (val) *val = p;
-      }
-      return res;
-    }
-  };
-
-  //  catchall
-  template <typename T>
-    struct traits_asptr < std::vector< std::vector<T> > > {
-    static int asptr(SEXP obj, std::vector< std::vector<T> > **val) {
-      std::vector< std::vector<T> > *p;
-      Rprintf("vector of vectors - unsupported content\n");
-      int res = SWIG_R_ConvertPtr(obj, (void**)&p, type_info< std::vector< std::vector<T> > > (), 0);
-      if (SWIG_IsOK(res)) {
-        if (val) *val = p;
-      }
-      return res;
-    }
-  };
-
-  }
-%}
-
-#define %swig_vector_methods(Type...) %swig_sequence_methods(Type)
-#define %swig_vector_methods_val(Type...) %swig_sequence_methods_val(Type);
-
-%define %traits_type_name(Type...)
-%fragment(SWIG_Traits_frag(Type), "header",
-          fragment="StdTraits",fragment="StdVectorTraits") {
-  namespace swig {
-    template <>  struct traits< Type > {
-      typedef pointer_category category;
-      static const char* type_name() {
-        return #Type;
-      }
-    };
-  }
- }
-%enddef
-
-%include <std/std_vector.i>
-
-%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<double>)
-%traits_type_name(std::vector<double>)
-%typemap("rtypecheck") std::vector<double>, std::vector<double> const, std::vector<double> const&
-    %{ is.numeric($arg) %}
-%typemap("rtype") std::vector<double> "numeric"
-%typemap("scoercein") std::vector<double>, std::vector<double> const, std::vector<double> const& "";
-
-%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<float>)
-%traits_type_name(std::vector<float>)
-%typemap("rtypecheck") std::vector<float>, std::vector<float> const, std::vector<float> const&
-   %{ is.numeric($arg) %}
-%typemap("rtype") std::vector<float> "numeric"
-%typemap("scoercein") std::vector<double>, std::vector<float> const, std::vector<float> const& "";
-
-%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<bool>);
-%traits_type_name(std::vector<bool>);
-%typemap("rtypecheck") std::vector<bool> , std::vector<bool> const, std::vector<bool> const&
-   %{ is.logical($arg) %}
-%typemap("rtype") std::vector<bool> "logical"
-%typemap("scoercein") std::vector<bool> , std::vector<bool> const, std::vector<bool> const& "$input = as.logical($input);";
-
-%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<int>);
-%traits_type_name(std::vector<int>);
-%typemap("rtypecheck") std::vector<int> , std::vector<int> const, std::vector<int> const&
-   %{ is.integer($arg) || is.numeric($arg) %}
-%typemap("rtype") std::vector<int> "integer"
-%typemap("scoercein") std::vector<int> , std::vector<int> const, std::vector<int> const& "$input = as.integer($input);";
-
-%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<unsigned int>);
-%traits_type_name(std::vector<unsigned int>);
-%typemap("rtypecheck") std::vector<unsigned int>, std::vector<unsigned int> const, std::vector<unsigned int> const&
-%{ is.integer($arg) || is.numeric($arg) %}
-%typemap("rtype") std::vector<unsigned int> "integer"
-%typemap("scoercein") std::vector<unsigned int>, std::vector<unsigned int> const, std::vector<unsigned int> const& "$input = as.integer($input);";
-
-%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<std::vector<unsigned int> >);
-%traits_type_name(std::vector< std::vector<unsigned int> >);
-%typemap("rtypecheck") std::vector<std::vector<unsigned int> >, std::vector<std::vector<unsigned int> > const, std::vector<std::vector<unsigned int> >const&
-   %{ is.list($arg) && all(sapply($arg , is.integer) || sapply($arg, is.numeric)) %}
-%typemap("rtype") std::vector<std::vector<unsigned int> > "list"
-%typemap("scoercein") std::vector< std::vector<unsigned int> >, std::vector<std::vector<unsigned int> > const, std::vector<std::vector<unsigned int> >const& "$input = lapply($input, as.integer);";
-
-%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<std::vector<int> >);
-%traits_type_name(std::vector< std::vector<int> >);
-%typemap("rtypecheck") std::vector<std::vector<int> >, std::vector<std::vector<int> > const, std::vector<std::vector<int> >const&
-   %{ is.list($arg) && all(sapply($arg , is.integer) || sapply($arg, is.numeric)) %}
-%typemap("rtype") std::vector<std::vector<int> > "list"
-%typemap("scoercein") std::vector< std::vector<int> >, std::vector<std::vector<int> > const, std::vector<std::vector<int> >const& "$input = lapply($input, as.integer);";
-
-%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<std::vector<float> >);
-%traits_type_name(std::vector< std::vector<float> >);
-%typemap("rtypecheck") std::vector<std::vector<float> >, std::vector<std::vector<float> > const, std::vector<std::vector<float> >const&
-   %{ is.list($arg) && all(sapply($arg , is.integer) || sapply($arg, is.numeric)) %}
-%typemap("rtype") std::vector<std::vector<float> > "list"
-%typemap("scoercein") std::vector< std::vector<float> >, std::vector<std::vector<float> > const, std::vector<std::vector<float> >const& "$input = lapply($input, as.numeric);";
-
-%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<std::vector<double> >);
-%traits_type_name(std::vector< std::vector<double> >);
-%typemap("rtypecheck") std::vector<std::vector<double> >, std::vector<std::vector<double> > const, std::vector<std::vector<double> >const&
-   %{ is.list($arg) && all(sapply($arg , is.integer) || sapply($arg, is.numeric)) %}
-%typemap("rtype") std::vector<std::vector<double> > "list"
-%typemap("scoercein") std::vector< std::vector<double> >, std::vector<std::vector<double> > const, std::vector<std::vector<double> >const&
- "$input = lapply($input, as.numeric);";
-
-%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<std::vector<bool> >);
-%traits_type_name(std::vector< std::vector<bool> >);
-%typemap("rtypecheck") std::vector<std::vector<bool> >, std::vector<std::vector<bool> > const, std::vector<std::vector<bool> >const&
-   %{ is.list($arg) && all(sapply($arg , is.integer) || sapply($arg, is.numeric)) %}
-%typemap("rtype") std::vector<std::vector<bool> > "list"
-%typemap("scoercein") std::vector< std::vector<bool> >, std::vector<std::vector<bool> > const, std::vector<std::vector<bool> >const& "$input = lapply($input, as.logical);";
-
-// we don't want these to be given R classes as they
-// have already been turned into R vectors.
-%typemap(scoerceout) std::vector<double>,
-   std::vector<double> *,
-   std::vector<double> &,
-   std::vector<bool>,
-   std::vector<bool> *,
-   std::vector<bool> &,
-   std::vector<unsigned int>,
-   std::vector<unsigned int> *,
-   std::vector<unsigned int> &,
- // vectors of vectors
-   std::vector< std::vector<unsigned int> >,
-   std::vector< std::vector<unsigned int> >*,
-   std::vector< std::vector<unsigned int> >&,
-   std::vector< std::vector<int> >,
-   std::vector< std::vector<int> >*,
-   std::vector< std::vector<int> >&,
-   std::vector< std::vector<float> >,
-   std::vector< std::vector<float> >*,
-   std::vector< std::vector<float> >&,
-   std::vector< std::vector<double> >,
-   std::vector< std::vector<double> >*,
-   std::vector< std::vector<double> >&,
-   std::vector< std::vector<bool> >,
-   std::vector< std::vector<bool> >*,
-   std::vector< std::vector<bool> >&
-
-
- %{    %}
diff --git a/share/swig/2.0.11/ruby/Makefile.swig b/share/swig/2.0.11/ruby/Makefile.swig
deleted file mode 100644
index a7f3ae3..0000000
--- a/share/swig/2.0.11/ruby/Makefile.swig
+++ /dev/null
@@ -1,42 +0,0 @@
-# File : Makefile.swig
-# Makefile for a SWIG module.  Use this file if you are
-# producing a Ruby extension for general use or distribution.
-#
-# 1.  Prepare extconf.rb.
-# 2.  Modify this file as appropriate.
-# 3.  Type 'make -f Makefile.swig' to generate wrapper code and Makefile.
-# 4.  Type 'make' to build your extension.
-# 5.  Type 'make install' to install your extension.
-# 
-
-MODULE    = yourmodule
-FEATURE   = $(MODULE)
-INTERFACE = $(MODULE).i
-RUBY      = ruby
-SWIG      = swig
-
-# for C extension
-SWIGOPT   = -ruby
-WRAPPER   = $(MODULE)_wrap.c
-
-## for C++ extension
-#SWIGOPT   = -ruby -c++
-#WRAPPER   = $(MODULE)_wrap.cc
-
-
-swigall: $(WRAPPER) Makefile
-
-$(WRAPPER): $(INTERFACE)
-	$(SWIG) $(SWIGOPT) -o $@ $(INTERFACE)
-
-Makefile: extconf.rb
-	$(RUBY) extconf.rb
-	@if [ -f Makefile ] ; then\
-		echo "include Makefile.swig" >> Makefile;\
-	fi
-
-swigclean:
-	@if [ -f Makefile ] ; then\
-		make -f Makefile clean;\
-	fi
-	rm -f Makefile $(WRAPPER)
diff --git a/share/swig/2.0.11/ruby/director.swg b/share/swig/2.0.11/ruby/director.swg
deleted file mode 100644
index a5daf21..0000000
--- a/share/swig/2.0.11/ruby/director.swg
+++ /dev/null
@@ -1,381 +0,0 @@
-/* -----------------------------------------------------------------------------
- * director.swg
- *
- * This file contains support for director classes that proxy
- * method calls from C++ to Ruby extensions.
- * ----------------------------------------------------------------------------- */
-
-/*
-  Use -DSWIG_DIRECTOR_NOUEH if you prefer to avoid the use of the
-  Undefined Exception Handler provided by swig.
-*/
-#ifndef SWIG_DIRECTOR_NOUEH
-#ifndef SWIG_DIRECTOR_UEH
-#define SWIG_DIRECTOR_UEH
-#endif
-#endif
-
-#ifdef __cplusplus
-
-#include <string>
-#include <iostream>
-#include <map>
-
-# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG)
-
-namespace Swig {
-  /* memory handler */
-  struct GCItem 
-  {
-    virtual ~GCItem()
-    {
-    }
-
-    virtual ruby_owntype get_own() const
-    {
-      return 0;
-    }
-  };
-  
-  struct GCItem_var
-  {
-    GCItem_var(GCItem *item = 0) : _item(item)
-    {
-    }
-
-    GCItem_var& operator=(GCItem *item)
-    {
-      GCItem *tmp = _item;
-      _item = item;
-      delete tmp;
-      return *this;
-    }
-    
-    ~GCItem_var() 
-    {
-      delete _item;
-    }
-    
-    GCItem * operator->() const
-    {
-      return _item;
-    }
-    
-  private:
-    GCItem *_item;
-  };
-
-
-  template <typename Type>
-  struct GCItem_T : GCItem
-  {
-    GCItem_T(Type *ptr) : _ptr(ptr)
-    {
-    }
-    
-    virtual ~GCItem_T() 
-    {
-      delete _ptr;
-    }
-    
-  private:
-    Type *_ptr;
-  };
-
-  struct GCItem_Object : GCItem
-  {
-    GCItem_Object(ruby_owntype own) : _own(own)
-    {
-    }
-    
-    virtual ~GCItem_Object() 
-    {
-    }
-
-    ruby_owntype get_own() const
-    {
-      return _own;
-    }
-    
-  private:
-    ruby_owntype _own;
-  };
-
-
-  template <typename Type>
-  struct GCArray_T : GCItem
-  {
-    GCArray_T(Type *ptr) : _ptr(ptr)
-    {
-    }
-    
-    virtual ~GCArray_T() 
-    {
-      delete[] _ptr;
-    }
-    
-  private:
-    Type *_ptr;
-  };
-
-
-  /* body args */
-  struct body_args {
-    VALUE recv;
-    ID id;
-    int argc;
-    VALUE *argv;
-  };
-  
-  /* Base class for director exceptions */
-  class DirectorException {
-  protected:
-    VALUE swig_error;
-    std::string swig_msg;
-  protected:
-    DirectorException(VALUE error)
-      : swig_error(error)
-    {
-    }
-    
-    DirectorException(VALUE error, const char* hdr, const char* msg ="") 
-      : swig_error(error), swig_msg(hdr) {
-      if (strlen(msg)) {
-	swig_msg += " ";
-	swig_msg += msg;
-      }
-      if (swig_msg.size()) {
-	VALUE str = rb_str_new(swig_msg.data(), swig_msg.size());
-	swig_error = rb_exc_new3(error, str);
-      } else {
-	swig_error = error;
-      }
-    }
-  public:
-    VALUE getType() const  { 
-      return CLASS_OF(swig_error); 
-    }
-    VALUE getError() const {
-      return swig_error;
-    }
-    const std::string& getMessage() const 
-    {
-      return swig_msg;
-    }
-    
-    virtual ~DirectorException() {}
-  };
-  
-  /* unknown exception handler  */
-
-  class UnknownExceptionHandler 
-  {
-#ifdef SWIG_DIRECTOR_UEH
-    static void handler() {
-      try {
-	throw;
-      } catch (DirectorException& e) {
-	std::cerr << "SWIG Director exception caught:" << std::endl
-		  << e.getMessage() << std::endl;
-      } catch (std::exception& e) {
-	std::cerr << "std::exception caught: "<< e.what() << std::endl;
-      } catch (...) {
-	std::cerr << "Unknown exception caught." << std::endl;
-      }      
-      std::cerr << std::endl
-		<< "Ruby interpreter traceback:" << std::endl;
-      std::cerr << std::endl;      
-      std::cerr << "This exception was caught by the SWIG unexpected exception handler." << std::endl
-		<< "Try using %feature(\"director:except\") to avoid reaching this point." << std::endl
-		<< std::endl
-		<< "Exception is being re-thrown, program will like abort/terminate." << std::endl;
-      throw;
-    }
-    
-  public:    
-    std::unexpected_handler old;
-    UnknownExceptionHandler(std::unexpected_handler nh = handler)
-    {
-      old = std::set_unexpected(nh);
-    }
-
-    ~UnknownExceptionHandler()
-    {
-      std::set_unexpected(old);
-    }
-#endif
-  };
-
-
-  /* Type mismatch in the return value from a Ruby method call */
-  class DirectorTypeMismatchException : public Swig::DirectorException {
-  public:
-    DirectorTypeMismatchException(VALUE error, const char *msg="")
-      : Swig::DirectorException(error, "SWIG director type mismatch", msg) 
-    {
-    }
-
-    DirectorTypeMismatchException(const char *msg="")
-      : Swig::DirectorException(rb_eTypeError, "SWIG director type mismatch", msg) 
-    {
-    }
-
-    static void raise(VALUE error, const char *msg) {
-      throw DirectorTypeMismatchException(error, msg);
-    }
-
-    static void raise(const char *msg) {
-      throw DirectorTypeMismatchException(msg);
-    }
-  };
-
-  /* Any Ruby exception that occurs during a director method call */
-  class DirectorMethodException : public Swig::DirectorException {
-  public:
-    DirectorMethodException(VALUE error) 
-      : Swig::DirectorException(error) {
-    }
-
-    DirectorMethodException(const char* msg = "") 
-      : Swig::DirectorException(rb_eRuntimeError, "SWIG director method error.", msg) {
-    }
-    
-    static void raise(VALUE error)
-    {
-      throw DirectorMethodException(error);
-    }    
-  };
-
-  /* Attempted to call a pure virtual method via a director method */
-  class DirectorPureVirtualException : public Swig::DirectorException
-  {
-  public:
-    DirectorPureVirtualException(const char* msg = "") 
-      : DirectorException(rb_eRuntimeError, "SWIG director pure virtual method called", msg)
-    { 
-    }
-
-    static void raise(const char *msg) 
-    {
-      throw DirectorPureVirtualException(msg);
-    }
-  };
-
-  /* Simple thread abstraction for pthreads on win32 */
-#ifdef __THREAD__
-# define __PTHREAD__
-# if defined(_WIN32) || defined(__WIN32__)
-#  define pthread_mutex_lock EnterCriticalSection
-#  define pthread_mutex_unlock LeaveCriticalSection
-#  define pthread_mutex_t CRITICAL_SECTION
-#  define SWIG_MUTEX_INIT(var) var
-# else
-#  include <pthread.h>
-#  define SWIG_MUTEX_INIT(var) var = PTHREAD_MUTEX_INITIALIZER 
-# endif
-#endif
-
-#ifdef  __PTHREAD__
-  struct Guard
-  {
-    pthread_mutex_t *_mutex;
-    
-    Guard(pthread_mutex_t &mutex) : _mutex(&mutex)
-    {
-      pthread_mutex_lock(_mutex);
-    }
-    
-    ~Guard()
-    {
-      pthread_mutex_unlock(_mutex);
-    }
-  };
-# define SWIG_GUARD(mutex) Guard _guard(mutex)
-#else
-# define SWIG_GUARD(mutex) 
-#endif
-
-  /* director base class */
-  class Director {
-  private:
-    /* pointer to the wrapped Ruby object */
-    VALUE swig_self;
-    /* flag indicating whether the object is owned by Ruby or c++ */
-    mutable bool swig_disown_flag;
-
-  public:
-    /* wrap a Ruby object, optionally taking ownership */
-    Director(VALUE self) : swig_self(self), swig_disown_flag(false) {
-    }
-
-    /* discard our reference at destruction */
-    virtual ~Director() {
-    }
-
-    /* return a pointer to the wrapped Ruby object */
-    VALUE swig_get_self() const { 
-      return swig_self; 
-    }
-
-    /* acquire ownership of the wrapped Ruby object (the sense of "disown"
-     * is from Ruby) */
-    void swig_disown() const { 
-      if (!swig_disown_flag) { 
-        swig_disown_flag = true;
-      } 
-    }
-
-  /* ownership management */
-  private:
-    typedef std::map<void*, GCItem_var> swig_ownership_map;
-    mutable swig_ownership_map swig_owner;
-#ifdef __PTHREAD__
-    static pthread_mutex_t swig_mutex_own;
-#endif
-
-  public:
-    template <typename Type>
-    void swig_acquire_ownership_array(Type *vptr)  const
-    {
-      if (vptr) {
-	SWIG_GUARD(swig_mutex_own);
-	swig_owner[vptr] = new GCArray_T<Type>(vptr);
-      }
-    }
-    
-    template <typename Type>
-    void swig_acquire_ownership(Type *vptr)  const
-    {
-      if (vptr) {	
-	SWIG_GUARD(swig_mutex_own);
-	swig_owner[vptr] = new GCItem_T<Type>(vptr);
-      }
-    }
-
-    void swig_acquire_ownership_obj(void *vptr, ruby_owntype own) const
-    {
-      if (vptr && own) {
-	SWIG_GUARD(swig_mutex_own);
-	swig_owner[vptr] = new GCItem_Object(own);
-      }
-    }
-    
-    ruby_owntype swig_release_ownership(void *vptr) const
-    {
-      ruby_owntype own = 0;
-      if (vptr) {
-	SWIG_GUARD(swig_mutex_own);
-	swig_ownership_map::iterator iter = swig_owner.find(vptr);
-	if (iter != swig_owner.end()) {
-	  own = iter->second->get_own();
-	  swig_owner.erase(iter);
-	}
-      }
-      return own;
-    }
-  };
-}
-
-#endif /* __cplusplus */
-
-
diff --git a/share/swig/2.0.11/ruby/file.i b/share/swig/2.0.11/ruby/file.i
deleted file mode 100644
index d64937e..0000000
--- a/share/swig/2.0.11/ruby/file.i
+++ /dev/null
@@ -1,39 +0,0 @@
-// FILE *
-%{
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Ruby 1.9 changed the file name of this header
-#ifdef HAVE_RUBY_IO_H
-#include "ruby/io.h"
-#else
-#include "rubyio.h"
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-%}
-
-%typemap(in) FILE *READ {
-    OpenFile *of;
-    GetOpenFile($input, of);
-    rb_io_check_readable(of);
-    $1 = GetReadFile(of);
-    rb_read_check($1);
-}
-
-%typemap(in) FILE *READ_NOCHECK {
-    OpenFile *of;
-    GetOpenFile($input, of);
-    rb_io_check_readable(of);
-    $1 = GetReadFile(of);
-}
-
-%typemap(in) FILE *WRITE {
-    OpenFile *of;
-    GetOpenFile($input, of);
-    rb_io_check_writable(of);
-    $1 = GetWriteFile(of);
-}
diff --git a/share/swig/2.0.11/ruby/rubyclasses.swg b/share/swig/2.0.11/ruby/rubyclasses.swg
deleted file mode 100644
index 5537136..0000000
--- a/share/swig/2.0.11/ruby/rubyclasses.swg
+++ /dev/null
@@ -1,404 +0,0 @@
-#ifdef __cplusplus
-
-/*
-  GC_VALUE is used as a replacement of Ruby's VALUE.
-  GC_VALUE automatically handles registering and unregistering
-  of the underlying Ruby object with the GC.
-
-  It can be used if you want to create STL containers of VALUEs, such as:
-  
-     std::vector< GC_VALUE >;
-
-  or as a member variable:
-  
-     struct A {
-       GC_VALUE _obj;
-       A(VALUE o) : _obj(o) {
-       }
-     };
-
-   or as a input/output value (not much use for this, as VALUE works just as
-   well here, thou):
-
-     GC_VALUE func(GC_VALUE obj) { 
-       GC_VALUE out = rb_obj_classname(obj);
-       return out;
-     }
-
-
-   GC_VALUE is 'visible' at the wrapped side, so you can do:
-
-      %template(RubyVector) std::vector<swig::GC_VALUE>;
-
-   and all the proper typemaps will be used.
-   
-*/
-
-%fragment("GC_VALUE_definition","header") {
-namespace swig {
-  class SwigGCReferences {
-    // Hash of all GC_VALUE's currently in use
-    static SwigGCReferences s_references;
-
-    VALUE _hash;
-
-    SwigGCReferences() : _hash(Qnil) {
-    }
-    ~SwigGCReferences() {
-      if (_hash != Qnil)
-        rb_gc_unregister_address(&_hash);
-    }
-    static void EndProcHandler(VALUE) {
-      // Ruby interpreter ending - _hash can no longer be accessed.
-      s_references._hash = Qnil;
-    }
-  public:
-    static SwigGCReferences& instance() {
-      return s_references;
-    }
-    static void initialize() {
-      if (s_references._hash == Qnil) {
-        rb_set_end_proc(&EndProcHandler, Qnil);
-        s_references._hash = rb_hash_new();
-        rb_gc_register_address(&s_references._hash);
-      }
-    }
-    void GC_register(VALUE& obj) {
-      if (FIXNUM_P(obj) || SPECIAL_CONST_P(obj) || SYMBOL_P(obj))
-        return;
-      if (_hash != Qnil) {
-        VALUE val = rb_hash_aref(_hash, obj);
-        unsigned n = FIXNUM_P(val) ? NUM2UINT(val) : 0;
-        ++n;
-        rb_hash_aset(_hash, obj, INT2NUM(n));
-      }
-    }
-    void GC_unregister(const VALUE& obj) {
-      if (FIXNUM_P(obj) || SPECIAL_CONST_P(obj) || SYMBOL_P(obj))
-        return;
-      // this test should not be needed but I've noticed some very erratic
-      // behavior of none being unregistered in some very rare situations.
-      if (BUILTIN_TYPE(obj) == T_NONE)
-        return;
-      if (_hash != Qnil) {
-        VALUE val = rb_hash_aref(s_references._hash, obj);
-        unsigned n = FIXNUM_P(val) ? NUM2UINT(val) : 1;
-        --n;
-        if (n)
-          rb_hash_aset(s_references._hash, obj, INT2NUM(n));
-        else
-          rb_hash_delete(s_references._hash, obj);
-      }
-    }
-  };
-
-  class GC_VALUE {
-  protected:
-    VALUE  _obj;
-
-    static ID hash_id;
-    static ID   lt_id;
-    static ID   gt_id;
-    static ID   eq_id;
-    static ID   le_id;
-    static ID   ge_id;
-
-    static ID  pos_id;
-    static ID  neg_id;
-    static ID  inv_id;
-
-    static ID  add_id;
-    static ID  sub_id;
-    static ID  mul_id;
-    static ID  div_id;
-    static ID  mod_id;
-
-    static ID  and_id;
-    static ID   or_id;
-    static ID  xor_id;
-
-    static ID  lshift_id;
-    static ID  rshift_id;
-
-    struct OpArgs
-    {
-      VALUE src;
-      ID    id;
-      int   nargs;
-      VALUE target;
-    };
-
-
-  public:
-    GC_VALUE() : _obj(Qnil)
-    {
-    }
-
-    GC_VALUE(const GC_VALUE& item) : _obj(item._obj)
-    {
-      SwigGCReferences::instance().GC_register(_obj);
-    }
-    
-    GC_VALUE(VALUE obj) :_obj(obj)
-    {
-      SwigGCReferences::instance().GC_register(_obj);
-    }
-    
-    ~GC_VALUE() 
-    {
-      SwigGCReferences::instance().GC_unregister(_obj);
-    }
-    
-    GC_VALUE & operator=(const GC_VALUE& item) 
-    {
-      SwigGCReferences::instance().GC_unregister(_obj);
-      _obj = item._obj;
-      SwigGCReferences::instance().GC_register(_obj);
-      return *this;
-    }
-
-    operator VALUE() const
-    {
-      return _obj;
-    }
-
-    VALUE inspect() const
-    {
-      return rb_inspect(_obj);
-    }
-
-    VALUE to_s() const
-    {
-      return rb_inspect(_obj);
-    }
-
-    static VALUE swig_rescue_swallow(VALUE)
-    {
-      /*
-      VALUE errstr = rb_obj_as_string(rb_errinfo());
-      printf("Swallowing error: '%s'\n", RSTRING_PTR(StringValue(errstr)));
-      */
-      return Qnil; /* Swallow Ruby exception */
-    }
-
-    static VALUE swig_rescue_funcall(VALUE p)
-    {
-      OpArgs* args = (OpArgs*) p;
-      return rb_funcall(args->src, args->id, args->nargs, args->target);
-    }
-
-    bool relational_equal_op(const GC_VALUE& other, const ID& op_id, bool (*op_func)(const VALUE& a, const VALUE& b)) const
-    {
-      if (FIXNUM_P(_obj) && FIXNUM_P(other._obj)) {
-        return op_func(_obj, other._obj);
-      }
-      bool res = false;
-      VALUE ret = Qnil;
-      SWIG_RUBY_THREAD_BEGIN_BLOCK;
-      if (rb_respond_to(_obj, op_id)) {
-        OpArgs  args;
-        args.src    = _obj;
-        args.id     = op_id;
-        args.nargs  = 1;
-        args.target = VALUE(other);
-        ret = rb_rescue(RUBY_METHOD_FUNC(swig_rescue_funcall), VALUE(&args),
-                       (RUBY_METHOD_FUNC(swig_rescue_swallow)), Qnil);
-      }
-      if (ret == Qnil) {
-        VALUE a = rb_funcall(         _obj, hash_id, 0 );
-        VALUE b = rb_funcall( VALUE(other), hash_id, 0 );
-        res = op_func(a, b);
-      } else {
-        res = RTEST(ret);
-      }
-      SWIG_RUBY_THREAD_END_BLOCK;
-      return res;
-    }
-
-    static bool operator_eq(const VALUE& a, const VALUE& b) { return a == b; }
-    static bool operator_lt(const VALUE& a, const VALUE& b) { return a < b; }
-    static bool operator_le(const VALUE& a, const VALUE& b) { return a <= b; }
-    static bool operator_gt(const VALUE& a, const VALUE& b) { return a > b; }
-    static bool operator_ge(const VALUE& a, const VALUE& b) { return a >= b; }
-
-    bool operator==(const GC_VALUE& other) const { return relational_equal_op(other, eq_id, operator_eq); }
-    bool operator<(const GC_VALUE& other) const { return relational_equal_op(other, lt_id, operator_lt); }
-    bool operator<=(const GC_VALUE& other) const { return relational_equal_op(other, le_id, operator_le); }
-    bool operator>(const GC_VALUE& other) const { return relational_equal_op(other, gt_id, operator_gt); }
-    bool operator>=(const GC_VALUE& other) const { return relational_equal_op(other, ge_id, operator_ge); }
-
-    bool operator!=(const GC_VALUE& other) const
-    {
-      return !(this->operator==(other));
-    }
-
-    GC_VALUE unary_op(const ID& op_id) const
-    {
-      VALUE ret = Qnil;
-      SWIG_RUBY_THREAD_BEGIN_BLOCK;
-      OpArgs  args;
-      args.src    = _obj;
-      args.id     = op_id;
-      args.nargs  = 0;
-      args.target = Qnil;
-      ret = rb_rescue(RUBY_METHOD_FUNC(swig_rescue_funcall), VALUE(&args),
-                     (RUBY_METHOD_FUNC(swig_rescue_swallow)), Qnil);
-      SWIG_RUBY_THREAD_END_BLOCK;
-      return ret;
-    }
-
-    GC_VALUE operator+() const { return unary_op(pos_id); }
-    GC_VALUE operator-() const { return unary_op(neg_id); }
-    GC_VALUE operator~() const { return unary_op(inv_id); }
-
-    GC_VALUE binary_op(const GC_VALUE& other, const ID& op_id) const
-    {
-      VALUE ret = Qnil;
-      SWIG_RUBY_THREAD_BEGIN_BLOCK;
-      OpArgs  args;
-      args.src    = _obj;
-      args.id     = op_id;
-      args.nargs  = 1;
-      args.target = VALUE(other);
-      ret = rb_rescue(RUBY_METHOD_FUNC(swig_rescue_funcall), VALUE(&args),
-                     (RUBY_METHOD_FUNC(swig_rescue_swallow)), Qnil);
-      SWIG_RUBY_THREAD_END_BLOCK;
-      return GC_VALUE(ret);
-    }
-
-    GC_VALUE operator+(const GC_VALUE& other) const { return binary_op(other, add_id); }
-    GC_VALUE operator-(const GC_VALUE& other) const { return binary_op(other, sub_id); }
-    GC_VALUE operator*(const GC_VALUE& other) const { return binary_op(other, mul_id); }
-    GC_VALUE operator/(const GC_VALUE& other) const { return binary_op(other, div_id); }
-    GC_VALUE operator%(const GC_VALUE& other) const { return binary_op(other, mod_id); }
-    GC_VALUE operator&(const GC_VALUE& other) const { return binary_op(other, and_id); }
-    GC_VALUE operator^(const GC_VALUE& other) const { return binary_op(other, xor_id); }
-    GC_VALUE operator|(const GC_VALUE& other) const { return binary_op(other, or_id); }
-    GC_VALUE operator<<(const GC_VALUE& other) const { return binary_op(other, lshift_id); }
-    GC_VALUE operator>>(const GC_VALUE& other) const { return binary_op(other, rshift_id); }
-  };
-
-  ID  GC_VALUE::hash_id = rb_intern("hash");
-  ID  GC_VALUE::lt_id = rb_intern("<");
-  ID  GC_VALUE::gt_id = rb_intern(">");
-  ID  GC_VALUE::eq_id = rb_intern("==");
-  ID  GC_VALUE::le_id = rb_intern("<=");
-  ID  GC_VALUE::ge_id = rb_intern(">=");
-
-  ID  GC_VALUE::pos_id = rb_intern("+@");
-  ID  GC_VALUE::neg_id = rb_intern("-@");
-  ID  GC_VALUE::inv_id = rb_intern("~");
-
-  ID  GC_VALUE::add_id = rb_intern("+");
-  ID  GC_VALUE::sub_id = rb_intern("-");
-  ID  GC_VALUE::mul_id = rb_intern("*");
-  ID  GC_VALUE::div_id = rb_intern("/");
-  ID  GC_VALUE::mod_id = rb_intern("%");
-
-  ID  GC_VALUE::and_id = rb_intern("&");
-  ID  GC_VALUE::or_id  = rb_intern("|");
-  ID  GC_VALUE::xor_id = rb_intern("^");
-
-  ID  GC_VALUE::lshift_id = rb_intern("<<");
-  ID  GC_VALUE::rshift_id = rb_intern(">>");
-
-  SwigGCReferences SwigGCReferences::s_references;
-
-  typedef GC_VALUE LANGUAGE_OBJ;
-
-} // namespace swig
-
-} // %fragment(GC_VALUE_definition)
-
-
-
-namespace swig {
-
-  %apply VALUE   {GC_VALUE};
-
-  // Make sure this is the last typecheck done
-  %typecheck(999999,fragment="GC_VALUE_definition",noblock=1) GC_VALUE, GC_VALUE&, 
-    const GC_VALUE& { $1 = 1; };
-
-  /* For input */
-  %typemap(in,fragment="GC_VALUE_definition",noblock=1) GC_VALUE* (GC_VALUE r), GC_VALUE& (GC_VALUE r)  {
-     r = $input; $1 = &r;
-   }
-
-  /* For output */
-  %typemap(out,fragment="GC_VALUE_definition",noblock=1)  GC_VALUE {
-    $result = (VALUE)$1;
-  }
-  
-  %typemap(out,fragment="GC_VALUE_definition",noblock=1)  GC_VALUE*, GC_VALUE const & {
-    $result = (VALUE)*$1;
-  }
-
-  %nodirector GC_VALUE;
-
-  // We ignore the constructor so that user can never create a GC_VALUE 
-  // manually
-  %ignore GC_VALUE::GC_VALUE;
-
-  struct GC_VALUE {
-    VALUE inspect() const;
-    VALUE to_s() const;
-    GC_VALUE();
-  protected:
-    GC_VALUE(const GC_VALUE&);
-    ~GC_VALUE();
-  };
-
-  %exception GC_VALUE {};
-
-
-  %ignore LANGUAGE_OBJ;
-  typedef GC_VALUE LANGUAGE_OBJ;
-}
-
-
-%init {
-  swig::SwigGCReferences::initialize();
-}
-
-
-
-//
-// Fragment that contains traits to properly deal with GC_VALUE.
-// These functions may be invoked as a need of the from(), asval(),
-// asptr() and as() template functors, usually used in %typemaps.
-//
-%fragment(SWIG_Traits_frag(swig::GC_VALUE),"header",fragment="StdTraits",fragment="GC_VALUE_definition") {
-namespace swig {
-  template <>  struct traits<GC_VALUE > {
-    typedef value_category category;
-    static const char* type_name() { return "GC_VALUE"; }
-  };
-  
-  template <>  struct traits_from<GC_VALUE> {
-    typedef GC_VALUE value_type;
-    static VALUE from(const value_type& val) {
-      return static_cast<VALUE>(val);
-    }
-  };
-  
-  template <> 
-  struct traits_check<GC_VALUE, value_category> {
-    static bool check(GC_VALUE) {
-      return true;
-    }
-  };
-  
-  template <>  struct traits_asval<GC_VALUE > {   
-    typedef GC_VALUE value_type;
-    static int asval(VALUE obj, value_type *val) {
-      if (val) *val = obj;
-      return SWIG_OK;
-    }
-  };
-} // swig
-} // %fragment(traits for swig::GC_VALUE)
-
-
-#endif  // __cplusplus
-
diff --git a/share/swig/2.0.11/ruby/rubycontainer.swg b/share/swig/2.0.11/ruby/rubycontainer.swg
deleted file mode 100644
index d4eaa5f..0000000
--- a/share/swig/2.0.11/ruby/rubycontainer.swg
+++ /dev/null
@@ -1,1096 +0,0 @@
-/* -----------------------------------------------------------------------------
- * rubycontainer.swg
- *
- * Ruby sequence <-> C++ container wrapper
- *
- * This wrapper, and its iterator, allows a general use (and reuse) of
- * the mapping between C++ and Ruby, thanks to the C++ templates.
- *
- * Of course, it needs the C++ compiler to support templates, but
- * since we will use this wrapper with the STL containers, that should
- * be the case.
- * ----------------------------------------------------------------------------- */
-
-%{
-#include <iostream>
-%}
-
-
-#if !defined(SWIG_NO_EXPORT_ITERATOR_METHODS)
-# if !defined(SWIG_EXPORT_ITERATOR_METHODS)
-#  define SWIG_EXPORT_ITERATOR_METHODS SWIG_EXPORT_ITERATOR_METHODS
-# endif
-#endif
-
-%include <rubyiterators.swg>
-
-/**** The RubySequence C++ Wrap ***/
-
-%insert(header) %{
-#include <stdexcept>
-%}
-
-%include <std_except.i>
-
-
-%fragment("RubySequence_Base","header")
-{
-%#include <functional>
-
-
-namespace swig {
-  template < class T >
-  struct yield : public std::unary_function< T, bool >
-  {
-    bool
-    operator()( const T& v ) const
-    { 
-      return RTEST( rb_yield( swig::from< T >(v) ) );
-    }
-  };
-
-
-  inline size_t
-  check_index(ptrdiff_t i, size_t size, bool insert = false) {
-    if ( i < 0 ) {
-      if ((size_t) (-i) <= size)
-	return (size_t) (i + size);
-    } else if ( (size_t) i < size ) {
-      return (size_t) i;
-    } else if (insert && ((size_t) i == size)) {
-      return size;
-    }
-    
-    throw std::out_of_range("index out of range");
-  }
-
-  inline size_t
-  slice_index(ptrdiff_t i, size_t size) {
-    if ( i < 0 ) {
-      if ((size_t) (-i) <= size) {
-	return (size_t) (i + size);
-      } else {
-	throw std::out_of_range("index out of range");
-      }
-    } else {
-      return ( (size_t) i < size ) ? ((size_t) i) : size;
-    }
-  }
-
-  template <class Sequence, class Difference>
-  inline typename Sequence::iterator
-  getpos(Sequence* self, Difference i)  {
-    typename Sequence::iterator pos = self->begin();
-    std::advance(pos, check_index(i,self->size()));
-    return pos;
-  }
-
-  template <class Sequence, class Difference>
-  inline typename Sequence::const_iterator
-  cgetpos(const Sequence* self, Difference i)  {
-    typename Sequence::const_iterator pos = self->begin();
-    std::advance(pos, check_index(i,self->size()));
-    return pos;
-  }
-
-  template <class Sequence, class Difference>
-  inline Sequence*
-  getslice(const Sequence* self, Difference i, Difference j) {
-    typename Sequence::size_type size = self->size();
-    typename Sequence::size_type ii = swig::check_index(i, size);
-    typename Sequence::size_type jj = swig::slice_index(j, size);
-
-    if (jj > ii) {
-      typename Sequence::const_iterator vb = self->begin();
-      typename Sequence::const_iterator ve = self->begin();
-      std::advance(vb,ii);
-      std::advance(ve,jj);
-      return new Sequence(vb, ve);
-    } else {
-      return new Sequence();
-    }
-  }
-
-  template <class Sequence, class Difference, class InputSeq>
-  inline void
-  setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) {
-    typename Sequence::size_type size = self->size();
-    typename Sequence::size_type ii = swig::check_index(i, size, true);
-    typename Sequence::size_type jj = swig::slice_index(j, size);
-    if (jj < ii) jj = ii;
-    size_t ssize = jj - ii;
-    if (ssize <= v.size()) {
-      typename Sequence::iterator sb = self->begin();
-      typename InputSeq::const_iterator vmid = v.begin();
-      std::advance(sb,ii);
-      std::advance(vmid, jj - ii);
-      self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
-    } else {
-      typename Sequence::iterator sb = self->begin();
-      typename Sequence::iterator se = self->begin();
-      std::advance(sb,ii);
-      std::advance(se,jj);
-      self->erase(sb,se);
-      self->insert(sb, v.begin(), v.end());
-    }
-  }
-
-  template <class Sequence, class Difference>
-  inline void
-  delslice(Sequence* self, Difference i, Difference j) {
-    typename Sequence::size_type size = self->size();
-    typename Sequence::size_type ii = swig::check_index(i, size, true);
-    typename Sequence::size_type jj = swig::slice_index(j, size);
-    if (jj > ii) {
-      typename Sequence::iterator sb = self->begin();
-      typename Sequence::iterator se = self->begin();
-      std::advance(sb,ii);
-      std::advance(se,jj);
-      self->erase(sb,se);
-    }
-  }
-}
-}
-
-%fragment("RubySequence_Cont","header",
-	  fragment="<stddef.h>",
-	  fragment="StdTraits",
-	  fragment="RubySequence_Base",
-	  fragment="ConstIterator_T")
-{
-namespace swig
-{
-
-  /**
-   * This class is a proxy class for references, used to return and set values
-   * of an element of a Ruby Array of stuff.
-   * It can be used by RubySequence_InputIterator to make it work with STL
-   * algorithms.
-   * 
-   */
-  template <class T>
-  struct RubySequence_Ref
-  {
-    RubySequence_Ref(VALUE  seq, int index)
-      : _seq(seq), _index(index)
-    {
-    }
-    
-    operator T () const
-    {
-      VALUE item = rb_ary_entry(_seq, _index );
-      try {
-	return swig::as<T>(item, true);
-      } catch (std::exception& e) {
-	char msg[1024];
-	sprintf(msg, "in sequence element %d ", _index);
-	VALUE lastErr = rb_gv_get("$!");
-	if ( lastErr == Qnil ) {
-	  %type_error(swig::type_name<T>());
-	}
-	VALUE str = rb_str_new2(msg);
-	str = rb_str_cat2( str, e.what() );
-	SWIG_Ruby_ExceptionType( NULL, str );
-	throw;
-      }
-    }
-
-    RubySequence_Ref& operator=(const T& v)
-    {
-      rb_ary_set(_seq, _index, swig::from< T >(v));
-      return *this;
-    }
-
-  private:
-    VALUE  _seq;
-    int _index;
-  };
-
-
-  /**
-   * This class is a proxy to return a pointer to a class, usually
-   * RubySequence_Ref. 
-   * It can be used by RubySequence_InputIterator to make it work with STL
-   * algorithms.
-   * 
-   */
-  template <class T>
-  struct RubySequence_ArrowProxy
-  {
-    RubySequence_ArrowProxy(const T& x): m_value(x) {}
-    const T* operator->() const { return &m_value; }
-    operator const T*() const { return &m_value; }
-    T m_value;
-  };
-
-
-  /**
-   * Input Iterator.  This adapator class is a random access iterator that 
-   * allows you to use STL algorithms with a Ruby class (a Ruby Array by default).
-   * 
-   */
-  template <class T, class Reference = RubySequence_Ref< T > >
-  struct RubySequence_InputIterator
-  {
-    typedef RubySequence_InputIterator<T, Reference > self;
-
-    typedef std::random_access_iterator_tag iterator_category;
-    typedef Reference reference;
-    typedef T value_type;
-    typedef T* pointer;
-    typedef ptrdiff_t difference_type;
-
-    RubySequence_InputIterator()
-    {
-    }
-
-    RubySequence_InputIterator(VALUE  seq, int index)
-      : _seq(seq), _index(index)
-    {
-    }
-
-    reference operator*() const
-    {
-      return reference(_seq, _index);
-    }
-
-    RubySequence_ArrowProxy<T>
-    operator->() const {
-      return RubySequence_ArrowProxy<T>(operator*());
-    }
-
-    bool operator==(const self& ri) const
-    {
-      return (_index == ri._index) && (_seq == ri._seq);
-    }
-
-    bool operator!=(const self& ri) const
-    {
-      return !(operator==(ri));
-    }
-
-    self& operator ++ ()
-    {
-      ++_index;
-      return *this;
-    }
-
-    self& operator -- ()
-    {
-      --_index;
-      return *this;
-    }
-
-    self& operator += (difference_type n)
-    {
-      _index += n;
-      return *this;
-    }
-
-    self operator +(difference_type n) const
-    {
-      return self(_seq, _index + n);
-    }
-
-    self& operator -= (difference_type n)
-    {
-      _index -= n;
-      return *this;
-    }
-
-    self operator -(difference_type n) const
-    {
-      return self(_seq, _index - n);
-    }
-
-    difference_type operator - (const self& ri) const
-    {
-      return _index - ri._index;
-    }
-
-    bool operator < (const self& ri) const
-    {
-      return _index < ri._index;
-    }
-
-    reference
-    operator[](difference_type n) const
-    {
-      return reference(_seq, _index + n);
-    }
-
-  private:
-    VALUE  _seq;
-    difference_type _index;
-  };
-
-
-  /**
-   * This adaptor class allows you to use a Ruby Array as if it was an STL
-   * container, giving it begin(), end(), and iterators.
-   * 
-   */
-  template <class T>
-  struct RubySequence_Cont
-  {
-    typedef RubySequence_Ref<T> reference;
-    typedef const RubySequence_Ref<T> const_reference;
-    typedef T value_type;
-    typedef T* pointer;
-    typedef int difference_type;
-    typedef int size_type;
-    typedef const pointer const_pointer;
-    typedef RubySequence_InputIterator<T, reference> iterator;
-    typedef RubySequence_InputIterator<T, const_reference> const_iterator;
-
-    RubySequence_Cont(VALUE  seq) : _seq(0)
-    {
-      if (!rb_obj_is_kind_of(seq, rb_cArray)) {
-	throw std::invalid_argument("an Array is expected");
-      }
-      _seq = seq;
-    }
-
-    ~RubySequence_Cont()
-    {
-    }
-
-    size_type size() const
-    {
-      return RARRAY_LEN(_seq);
-    }
-
-    bool empty() const
-    {
-      return size() == 0;
-    }
-
-    iterator begin()
-    {
-      return iterator(_seq, 0);
-    }
-
-    const_iterator begin() const
-    {
-      return const_iterator(_seq, 0);
-    }
-
-    iterator end()
-    {
-      return iterator(_seq, size());
-    }
-
-    const_iterator end() const
-    {
-      return const_iterator(_seq, size());
-    }
-
-    reference operator[](difference_type n)
-    {
-      return reference(_seq, n);
-    }
-
-    const_reference operator[](difference_type n)  const
-    {
-      return const_reference(_seq, n);
-    }
-
-    bool check(bool set_err = false) const
-    {
-      int s = (int) size();
-      for (int i = 0; i < s; ++i) {
-	VALUE item = rb_ary_entry(_seq, i );
-	if (!swig::check<value_type>(item)) {
-	  if (set_err) {
-	    char msg[1024];
-	    sprintf(msg, "in sequence element %d", i);
-	    SWIG_Error(SWIG_RuntimeError, msg);
-	  }
-	  return false;
-	}
-      }
-      return true;
-    }
-
-  private:
-    VALUE  _seq;
-  };
-
-}
-}
-
-/** 
- * Macros used to typemap an STL iterator -> SWIGIterator conversion.
- * 
- */
-%define %swig_sequence_iterator(Sequence...)
-#if defined(SWIG_EXPORT_ITERATOR_METHODS)
-
-  %typemap(out,noblock=1,fragment="RubySequence_Cont")
-    const_iterator, const_reverse_iterator {
-    $result = SWIG_NewPointerObj(swig::make_const_iterator(%static_cast($1,const $type &),
-							   self),
-				 swig::ConstIterator::descriptor(),SWIG_POINTER_OWN);
-  }
-
-  %typemap(out,noblock=1,fragment="RubySequence_Cont")
-    iterator, reverse_iterator {
-    $result = SWIG_NewPointerObj(swig::make_nonconst_iterator(%static_cast($1,const $type &),
-							      self),
-				 swig::Iterator::descriptor(),SWIG_POINTER_OWN);
-  }
-
-  %typemap(out,noblock=1,fragment="RubySequence_Cont")
-    std::pair<const_iterator, const_iterator> {
-    $result = rb_ary_new2(2);
-    rb_ary_push($result, SWIG_NewPointerObj(swig::make_const_iterator(%static_cast($1,const $type &).first),
-					    swig::ConstIterator::descriptor(),SWIG_POINTER_OWN));
-    rb_ary_push($result, SWIG_NewPointerObj(swig::make_const_iterator(%static_cast($1,const $type &).second),
-					    swig::ConstIterator::descriptor(),SWIG_POINTER_OWN));
-  }
-
-  // std::map/multimap/set allow returning std::pair< iterator, iterator > from
-  // equal_range, but we cannot still modify the key, so the iterator is
-  // const.
-  %typemap(out,noblock=1,fragment="RubySequence_Cont")
-    std::pair<iterator, iterator> {
-    $result = rb_ary_new2(2);
-    rb_ary_push($result, SWIG_NewPointerObj(swig::make_const_iterator(%static_cast($1,const $type &).first),
-					    swig::ConstIterator::descriptor(),SWIG_POINTER_OWN));
-    rb_ary_push($result, SWIG_NewPointerObj(swig::make_const_iterator(%static_cast($1,const $type &).second),
-					    swig::ConstIterator::descriptor(),SWIG_POINTER_OWN));
-  }
-
-
-  %typemap(in,noblock=1,fragment="RubySequence_Cont")
-    const_iterator(swig::ConstIterator *iter = 0, int res),
-    const_reverse_iterator(swig::ConstIterator *iter = 0, int res) {
-    res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter),
-			  swig::ConstIterator::descriptor(), 0);
-    if (!SWIG_IsOK(res) || !iter) {
-      %argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
-    } else {
-      swig::ConstIterator_T<$type > *iter_t = dynamic_cast<swig::ConstIterator_T<$type > *>(iter);
-      if (iter_t) {
-	$1 = iter_t->get_current();
-      } else {
-	%argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
-      }
-    }
-  }
-
-  %typemap(in,noblock=1,fragment="RubySequence_Cont")
-    iterator(swig::Iterator *iter = 0, int res),
-    reverse_iterator(swig::Iterator *iter = 0, int res) {
-    res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter), swig::Iterator::descriptor(), 0);
-    if (!SWIG_IsOK(res) || !iter) {
-      %argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
-    } else {
-      swig::Iterator_T<$type > *iter_t = dynamic_cast<swig::Iterator_T<$type > *>(iter);
-      if (iter_t) {
-	$1 = iter_t->get_current();
-      } else {
-	%argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
-      }
-    }
-  }
-
-  %typecheck(%checkcode(ITERATOR),noblock=1,fragment="RubySequence_Cont")
-    const_iterator, const_reverse_iterator {
-    swig::ConstIterator *iter = 0;
-    int res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter), 
-			      swig::ConstIterator::descriptor(), 0);
-    $1 = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::ConstIterator_T<$type > *>(iter) != 0));
-  }
-
-  %typecheck(%checkcode(ITERATOR),noblock=1,fragment="RubySequence_Cont")
-    iterator, reverse_iterator {
-    swig::ConstIterator *iter = 0;
-    int res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter), 
-			      swig::Iterator::descriptor(), 0);
-    $1 = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::Iterator_T<$type > *>(iter) != 0));
-  }
-
-  %fragment("RubySequence_Cont");
-
-//   %newobject iterator;
-//   %newobject const_iterator;
-//   %extend  {
-//     swig::Iterator* iterator(VALUE* RUBY_SELF) {
-//       return swig::make_nonconst_iterator($self->begin(), $self->begin(), 
-// 				             $self->end(), *RUBY_SELF);
-//     }
-
-//     swig::ConstIterator* const_iterator(VALUE* RUBY_SELF) {
-//       return swig::make_const_iterator($self->begin(), $self->begin(), 
-// 					$self->end(), *RUBY_SELF);
-//     }
-//   }
-#endif //SWIG_EXPORT_ITERATOR_METHODS
-%enddef
-
-
-/**** The Ruby container methods  ****/
-
-
-
-%define %swig_container_methods(Container...)
-
-  %extend {
-
-  %newobject dup;
-  Container* dup()
-    {
-      return new Container(*$self);
-    }
-
-  }
-
-%enddef
-
-
-/**
- * Macro used to define common Ruby printing methods for STL container
- * 
- */
-%define %swig_sequence_printing_methods(Sequence...)
-
-  %extend {
-
-  VALUE inspect()
-    {
-      Sequence::const_iterator i = $self->begin();
-      Sequence::const_iterator e = $self->end();
-      const char *type_name = swig::type_name< Sequence >();
-      VALUE str = rb_str_new2(type_name);
-      str = rb_str_cat2( str, " [" );
-      bool comma = false;
-      VALUE tmp;
-      for ( ; i != e; ++i, comma = true )
-	{
-	  if (comma) str = rb_str_cat2( str, "," );
-	  tmp = swig::from< Sequence::value_type >( *i );
-	  tmp = rb_inspect( tmp );
-	  str = rb_str_buf_append( str, tmp );
-	}
-      str = rb_str_cat2( str, "]" );
-      return str;
-    }
-
-  VALUE to_a()
-    {
-      Sequence::const_iterator i = $self->begin();
-      Sequence::const_iterator e = $self->end();
-      VALUE ary = rb_ary_new2( std::distance( i, e ) );
-      VALUE tmp;
-      for ( ; i != e; ++i )
-	{
-	  tmp = swig::from< Sequence::value_type >( *i );
-	  rb_ary_push( ary, tmp );
-	}
-      return ary;
-    }
-
-  VALUE to_s()
-    {
-      Sequence::iterator i = $self->begin();
-      Sequence::iterator e = $self->end();
-      VALUE str = rb_str_new2( "" );
-      VALUE tmp;
-      for ( ; i != e; ++i )
-	{
-	  tmp = swig::from< Sequence::value_type >( *i );
-	  tmp = rb_obj_as_string( tmp );
-	  str = rb_str_buf_append( str, tmp );
-	}
-      return str;
-    }
-}
-%enddef
-
-
-/**
- * Macro used to add common methods to all STL sequence-type containers 
- * 
- */
-%define %swig_sequence_methods_common(Sequence...)
-  %swig_container_methods(%arg(Sequence))
-  %swig_sequence_iterator(%arg(Sequence))
-  %swig_sequence_printing_methods(%arg(Sequence))
-
-  %fragment("RubySequence_Base");
-
-  %extend {
-
-
-  VALUE slice( difference_type i, difference_type j )
-    {
-	if ( j <= 0 ) return Qnil;
-	std::size_t len = $self->size();
-	if ( i < 0 ) i = len - i;
-	j += i;
-	if ( static_cast<std::size_t>(j) >= len ) j = len-1;
-
-	VALUE r = Qnil;
-	try {
-	  r = swig::from< const Sequence* >( swig::getslice(self, i, j) );
-	}
-	catch( std::out_of_range )
-	  {
-	  }
-	return r;
-      }
-
-
-    Sequence* each()
-      {
-	if ( !rb_block_given_p() )
-	  rb_raise( rb_eArgError, "no block given");
-
-	VALUE r;
-	Sequence::const_iterator i = self->begin();
-	Sequence::const_iterator e = self->end();
-	for ( ; i != e; ++i )
-	  {
-	    r = swig::from< Sequence::value_type >(*i);
-	    rb_yield(r);
-	  }
-	
-	return self;
-      }
-
-    %newobject select;
-    Sequence* select() {
-      if ( !rb_block_given_p() )
-	rb_raise( rb_eArgError, "no block given" );
-
-      Sequence* r = new Sequence;
-      Sequence::const_iterator i = $self->begin();
-      Sequence::const_iterator e = $self->end();
-      for ( ; i != e; ++i )
-	{
-	  VALUE v = swig::from< Sequence::value_type >(*i);
-	  if ( RTEST( rb_yield(v) ) )
-	    $self->insert( r->end(), *i);
-	}
-	
-      return r;
-    }
-
-    VALUE delete_at(difference_type i) {
-      VALUE r = Qnil;
-      try {
-	Sequence::iterator at = swig::getpos(self, i);
-	r = swig::from< Sequence::value_type >( *(at) );
-	$self->erase(at); 
-      }
-      catch (std::out_of_range)
-	{
-	}
-      return r;
-    }
-
-
-    VALUE __delete2__(const value_type& i) {
-      VALUE r = Qnil;
-      return r;
-    }
-
-  }
-%enddef
-
-
-/**
- * Macro used to add functions for back insertion of values in
- * STL Sequence containers
- * 
- */
-%define %swig_sequence_back_inserters( Sequence... )
-  %extend {
-
-    VALUE pop() {
-      if ($self->empty()) return Qnil;
-      Sequence::value_type x = self->back();
-      $self->pop_back();
-      return swig::from< Sequence::value_type >( x );
-    }
-
-    %alias push "<<";
-    const value_type push( const value_type& e ) {
-      $self->push_back( e );
-      return e;
-    }
-
-    %newobject reject;
-    Sequence* reject() {
-      if ( !rb_block_given_p() )
-	rb_raise( rb_eArgError, "no block given" );
-
-      Sequence* r = new Sequence;
-      std::remove_copy_if( $self->begin(), $self->end(),              
-			   std::back_inserter(*r),
-			   swig::yield< Sequence::value_type >() );
-      return r;
-    }
-
-  }
-%enddef
-
-%define %swig_sequence_methods_extra(Sequence...)
-  %extend {
-    %alias reject_bang "delete_if";
-    Sequence* reject_bang() {
-      if ( !rb_block_given_p() )
-	rb_raise( rb_eArgError, "no block given" );
-
-      $self->erase( std::remove_if( $self->begin(), $self->end(),
-            swig::yield< Sequence::value_type >() ), $self->end() );
-      return $self;
-    }
-  }
-%enddef
-
-/**
- * Macro used to add functions for Sequences
- * 
- */
-%define %swig_sequence_methods(Sequence...)
-  %swig_sequence_methods_common(%arg(Sequence));
-  %swig_sequence_methods_extra(%arg(Sequence));
-  %swig_sequence_back_inserters(%arg(Sequence));
-
-  %extend {
-
-    VALUE at(difference_type i) const {
-      VALUE r = Qnil;
-      try {
-	r = swig::from< Sequence::value_type >( *(swig::cgetpos(self, i)) );
-      }
-      catch( std::out_of_range )
-	{
-	}
-      return r;
-    }
-
-    VALUE __getitem__(difference_type i, difference_type j) const {
-      if ( j <= 0 ) return Qnil;
-      std::size_t len = $self->size();
-      if ( i < 0 ) i = len - i;
-      j += i; if ( static_cast<std::size_t>(j) >= len ) j = len-1;
-
-      VALUE r = Qnil;
-      try {
-	r = swig::from< const Sequence* >( swig::getslice(self, i, j) );
-      }
-      catch( std::out_of_range )
-	{
-	}
-      return r;
-    }
-
-    VALUE __getitem__(difference_type i) const {
-      VALUE r = Qnil;
-      try {
-	r = swig::from< Sequence::value_type >( *(swig::cgetpos(self, i)) );
-      }
-      catch( std::out_of_range )
-	{
-	}
-      return r;
-    }
-
-    VALUE __getitem__(VALUE i) const {
-      if ( rb_obj_is_kind_of( i, rb_cRange ) == Qfalse )
-	{
-	  rb_raise( rb_eTypeError, "not a valid index or range" );
-	}
-
-      VALUE r = Qnil;
-      static ID id_end   = rb_intern("end");
-      static ID id_start = rb_intern("begin");
-      static ID id_noend = rb_intern("exclude_end?");
-
-      VALUE start = rb_funcall( i, id_start, 0 );
-      VALUE end   = rb_funcall( i, id_end, 0 );
-      bool  noend = ( rb_funcall( i, id_noend, 0 ) == Qtrue );
-
-      int len = $self->size();
-
-      int s = NUM2INT( start );
-      if ( s < 0 ) s = len + s;
-      else if ( s >= len ) return Qnil;
-
-      int e = NUM2INT( end );
-      if ( e < 0 ) e = len + e;
-
-      if ( e < s ) return Qnil; //std::swap( s, e );
-
-      if ( noend ) e -= 1;
-      if ( e >= len ) e = len - 1;
-
-      return swig::from< Sequence* >( swig::getslice(self, s, e+1) );
-    }
-
-    VALUE __setitem__(difference_type i, const value_type& x)
-      {
-	std::size_t len = $self->size();
-	if ( i < 0 ) i = len - i;
-	else if ( static_cast<std::size_t>(i) >= len )
-	  $self->resize( i+1, x );
-	else
-	  *(swig::getpos(self,i)) = x;
-
-	return swig::from< Sequence::value_type >( x );
-      }
-
-    VALUE __setitem__(difference_type i, difference_type j, const Sequence& v) 
-      throw (std::invalid_argument) {
-
-      if ( j <= 0 ) return Qnil;
-      std::size_t len = $self->size();
-      if ( i < 0 ) i = len - i;
-      j += i; 
-      if ( static_cast<std::size_t>(j) >= len ) {
-	$self->resize( j+1, *(v.begin()) );
-	j = len-1;
-      }
-
-      VALUE r = Qnil;
-      swig::setslice(self, i, j, v);
-      r = swig::from< const Sequence* >( &v );
-      return r;
-    }
-
- }
-%enddef
-
-%define %swig_sequence_methods_val(Sequence...)
-  %swig_sequence_methods(%arg(Sequence))
-%enddef
-
-
-/**
- * Macro used to add functions for front insertion of
- * elements in STL sequence containers that support it.
- * 
- */
-%define %swig_sequence_front_inserters( Sequence... )
-
-%extend {
-
-  VALUE shift()
-    {
-      if ($self->empty()) return Qnil;
-      Sequence::value_type x = self->front();
-      $self->erase( $self->begin() );
-      return swig::from< Sequence::value_type >( x );
-    }
-
-  %typemap(in) (int argc, VALUE* argv) {
-    $1 = argc - 1;
-    $2 = argv + 1;
-  }
-
-  Sequence* insert( difference_type pos, int argc, VALUE* argv, ... )
-    {
-      std::size_t len = $self->size();
-      std::size_t   i = swig::check_index( pos, len, true );
-      Sequence::iterator start;
-
-      VALUE elem = argv[0];
-      int idx = 0;
-      try {
-	Sequence::value_type val = swig::as<Sequence::value_type>( elem, true );
-	if ( i >= len ) {
-	  $self->resize(i-1, val);
-	  return $self;
-	}
-	start = $self->begin();
-	std::advance( start, i );
-	$self->insert( start++, val );
-
-	for ( ++idx; idx < argc; ++idx )
-	  {
-	    elem = argv[idx];
-	    val = swig::as<Sequence::value_type>( elem );
-	    $self->insert( start++, val );
-	  }
-
-      } 
-      catch( std::invalid_argument )
-	{
-	  rb_raise( rb_eArgError, "%s",
-		    Ruby_Format_TypeError( "", 
-					   swig::type_name<Sequence::value_type>(),
-					   __FUNCTION__, idx+2, elem ));
-	}
-
-
-      return $self;
-    }
-
-  %typemap(in) (int argc, VALUE* argv) {
-    $1 = argc;
-    $2 = argv;
-  }
-
-  Sequence* unshift( int argc, VALUE* argv, ... )
-    {
-      for ( int idx = argc-1; idx >= 0; --idx )
-	{
-	  Sequence::iterator start = $self->begin();
-	  VALUE elem = argv[idx];
-	  try {
-	    Sequence::value_type val = swig::as<Sequence::value_type>( elem, true );
-	    $self->insert( start, val );
-	  }
-	  catch( std::invalid_argument )
-	    {
-	      rb_raise( rb_eArgError, "%s",
-			Ruby_Format_TypeError( "", 
-					       swig::type_name<Sequence::value_type>(),
-					       __FUNCTION__, idx+2, elem ));
-	    }
-	}
-
-      return $self;
-    }
-
-}
-%enddef
-
-
-//
-// Common fragments
-//
-
-%fragment("StdSequenceTraits","header",
-	  fragment="StdTraits",
-	  fragment="RubySequence_Cont",
-	  fragment="GC_VALUE_definition")
-{
-namespace swig {
-  template <class RubySeq, class Seq>
-  inline void
-  assign(const RubySeq& rubyseq, Seq* seq) {
-    // seq->assign(rubyseq.begin(), rubyseq.end()); // not used as not always implemented
-    typedef typename RubySeq::value_type value_type;
-    typename RubySeq::const_iterator it = rubyseq.begin();
-    for (;it != rubyseq.end(); ++it) {
-      seq->insert(seq->end(),(value_type)(*it));
-    }
-  }
-
-  template <class Seq, class T = typename Seq::value_type >
-  struct traits_asptr_stdseq {
-    typedef Seq sequence;
-    typedef T value_type;
-
-    static int asptr(VALUE obj, sequence **seq) {
-      if (rb_obj_is_kind_of(obj, rb_cArray) == Qtrue) {
-	try {
-	  RubySequence_Cont<value_type> rubyseq(obj);
-	  if (seq) {
-	    sequence *pseq = new sequence();
-	    assign(rubyseq, pseq);
-	    *seq = pseq;
-	    return SWIG_NEWOBJ;
-	  } else {
-	    return rubyseq.check() ? SWIG_OK : SWIG_ERROR;
-	  }
-	} catch (std::exception& e) {
-	  if (seq) {
-	    VALUE lastErr = rb_gv_get("$!");
-	    if (lastErr == Qnil) {
-	      rb_raise(rb_eTypeError, "%s", e.what());
-	    }
-	  }
-	  return SWIG_ERROR;
-	}
-      } else {
-	sequence *p;
-	if (SWIG_ConvertPtr(obj,(void**)&p,
-			    swig::type_info<sequence>(),0) == SWIG_OK) {
-	  if (seq) *seq = p;
-	  return SWIG_OLDOBJ;
-	}
-      }
-      return SWIG_ERROR;
-    }
-  };
-
-  // Partial specialization for GC_VALUE's.  No need to typecheck each
-  // element.
-  template< class Seq >
-  struct traits_asptr_stdseq< Seq, swig::GC_VALUE > {
-    typedef Seq sequence;
-    typedef swig::GC_VALUE value_type;
-
-    static int asptr(VALUE obj, sequence **seq) {
-      if (rb_obj_is_kind_of(obj, rb_cArray) == Qtrue) {
-	try {
-	  if (seq) {
-	    RubySequence_Cont<value_type> rubyseq(obj);
-	    sequence *pseq = new sequence();
-	    assign(rubyseq, pseq);
-	    *seq = pseq;
-	    return SWIG_NEWOBJ;
-	  } else {
-	    return true;
-	  }
-	} catch (std::exception& e) {
-	  if (seq) {
-	    VALUE lastErr = rb_gv_get("$!");
-	    if (lastErr == Qnil) {
-	      rb_raise(rb_eTypeError, "%s", e.what());
-	    }
-	  }
-	  return SWIG_ERROR;
-	}
-      } else {
-	sequence *p;
-	if (SWIG_ConvertPtr(obj,(void**)&p,
-			    swig::type_info<sequence>(),0) == SWIG_OK) {
-	  if (seq) *seq = p;
-	  return SWIG_OLDOBJ;
-	}
-      }
-      return SWIG_ERROR;
-    }
-  };
-
-  template <class Seq, class T = typename Seq::value_type >
-  struct traits_from_stdseq {
-    typedef Seq sequence;
-    typedef T value_type;
-    typedef typename Seq::size_type size_type;
-    typedef typename sequence::const_iterator const_iterator;
-
-    static VALUE from(const sequence& seq) {
-#ifdef SWIG_RUBY_EXTRA_NATIVE_CONTAINERS
-      swig_type_info *desc = swig::type_info<sequence>();
-      if (desc && desc->clientdata) {
-	return SWIG_NewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
-      }
-#endif
-      size_type size = seq.size();
-      if (size <= (size_type)INT_MAX) {
-	VALUE obj = rb_ary_new2((int)size);
-	int i = 0;
-	for (const_iterator it = seq.begin();
-	     it != seq.end(); ++it, ++i) {
-	  rb_ary_push(obj, swig::from< value_type >(*it));
-	}
-	rb_obj_freeze(obj);  // treat as immutable result
-	return obj;
-      } else {
-	rb_raise(rb_eRangeError,"sequence size not valid in ruby");
-	return Qnil;
-      }
-    }
-  };
-}
-}
-
-
-%include <rubycontainer_extended.swg>
diff --git a/share/swig/2.0.11/ruby/rubyprimtypes.swg b/share/swig/2.0.11/ruby/rubyprimtypes.swg
deleted file mode 100644
index df72e97..0000000
--- a/share/swig/2.0.11/ruby/rubyprimtypes.swg
+++ /dev/null
@@ -1,216 +0,0 @@
-/* -----------------------------------------------------------------------------
- * rubyprimtypes.swg
- * ----------------------------------------------------------------------------- */
-/* ------------------------------------------------------------
- * Primitive Types
- * ------------------------------------------------------------ */
-
-/* auxiliary ruby fail method */
-
-%fragment("SWIG_ruby_failed","header")
-{
-SWIGINTERN VALUE
-SWIG_ruby_failed(void)
-{
-  return Qnil;
-} 
-}
-
-%define %ruby_aux_method(Type, Method, Action)
-SWIGINTERN VALUE SWIG_AUX_##Method##(VALUE *args)
-{
-  VALUE obj = args[0];
-  VALUE type = TYPE(obj);
-  Type *res = (Type *)(args[1]);
-  *res = Action;
-  return obj;
-}
-%enddef
-
-
-/* boolean */
-
-%fragment(SWIG_From_frag(bool),"header") {
-SWIGINTERNINLINE VALUE
-SWIG_From_dec(bool)(bool value)
-{
-  return value ? Qtrue : Qfalse;
-}
-}
-
-%fragment(SWIG_AsVal_frag(bool),"header",
-	  fragment=SWIG_AsVal_frag(int)) {
-SWIGINTERN int
-SWIG_AsVal_dec(bool)(VALUE obj, bool *val)
-{
-  if (obj == Qtrue) {
-    if (val) *val = true;
-    return SWIG_OK;
-  } else if (obj == Qfalse) {
-    if (val) *val = false;
-    return SWIG_OK;
-  } else {
-    int res = 0;
-    if (SWIG_AsVal(int)(obj, &res) == SWIG_OK) {    
-      if (val) *val = res ? true : false;
-      return SWIG_OK;
-    }
-  }  
-  return SWIG_TypeError;
-}
-}
-
-/* long */
-
-%fragment(SWIG_From_frag(long),"header",
-	  fragment="<limits.h>") {
-  %define_as(SWIG_From_dec(long),           LONG2NUM)
-}
-
-%fragment(SWIG_AsVal_frag(long),"header",fragment="SWIG_ruby_failed") {
-%ruby_aux_method(long, NUM2LONG, type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj))
-
-SWIGINTERN int
-SWIG_AsVal_dec(long)(VALUE obj, long* val)
-{
-  VALUE type = TYPE(obj);
-  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
-    long v;
-    VALUE a[2];
-    a[0] = obj;
-    a[1] = (VALUE)(&v);
-    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
-      if (val) *val = v;
-      return SWIG_OK;
-    }
-  }
-  return SWIG_TypeError;
-}
-}
-
-/* unsigned long */
-
-%fragment(SWIG_From_frag(unsigned long),"header",
-	  fragment=SWIG_From_frag(long)) {
-SWIGINTERNINLINE VALUE
-SWIG_From_dec(unsigned long)(unsigned long value)
-{
-  return ULONG2NUM(value); 
-}
-}
-
-%fragment(SWIG_AsVal_frag(unsigned long),"header",fragment="SWIG_ruby_failed") {
-%ruby_aux_method(unsigned long, NUM2ULONG, type == T_FIXNUM ? NUM2ULONG(obj) : rb_big2ulong(obj))
-
-SWIGINTERN int
-SWIG_AsVal_dec(unsigned long)(VALUE obj, unsigned long *val) 
-{
-  VALUE type = TYPE(obj);
-  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
-    unsigned long v;
-    VALUE a[2];
-    a[0] = obj;
-    a[1] = (VALUE)(&v);
-    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
-      if (val) *val = v;
-      return SWIG_OK;
-    }
-  }
-  return SWIG_TypeError;
-}
-}
-
-/* long long */
-
-%fragment(SWIG_From_frag(long long),"header",
-	  fragment=SWIG_From_frag(long),
-	  fragment="<limits.h>") {
-SWIGINTERNINLINE VALUE 
-SWIG_From_dec(long long)(long long value)
-{
-  return LL2NUM(value);
-}
-}
-
-%fragment(SWIG_AsVal_frag(long long),"header",fragment="SWIG_ruby_failed") {
-%ruby_aux_method(long long, NUM2LL, type == T_FIXNUM ? NUM2LL(obj) : rb_big2ll(obj))
-
-SWIGINTERN int
-SWIG_AsVal_dec(long long)(VALUE obj, long long *val)
-{
-  VALUE type = TYPE(obj);
-  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
-    long long v;
-    VALUE a[2];
-    a[0] = obj;
-    a[1] = (VALUE)(&v);
-    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
-      if (val) *val = v;
-      return SWIG_OK;
-    }
-  }
-  return SWIG_TypeError;
-}
-}
-
-/* unsigned long long */
-
-%fragment(SWIG_From_frag(unsigned long long),"header",
-	  fragment=SWIG_From_frag(long long),
-	  fragment="<limits.h>") {
-SWIGINTERNINLINE VALUE 
-SWIG_From_dec(unsigned long long)(unsigned long long value)
-{
-  return ULL2NUM(value);
-}
-}
-
-%fragment(SWIG_AsVal_frag(unsigned long long),"header",fragment="SWIG_ruby_failed") {
-%ruby_aux_method(long long, NUM2ULL,  type == T_FIXNUM ? NUM2ULL(obj) : rb_big2ull(obj))
-
-SWIGINTERN int
-SWIG_AsVal_dec(unsigned long long)(VALUE obj, unsigned long long *val)
-{ 
-  VALUE type = TYPE(obj);
-  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
-    unsigned long long v;
-    VALUE a[2];
-    a[0] = obj;
-    a[1] = (VALUE)(&v);
-    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
-      if (val) *val = v;
-      return SWIG_OK;
-    }
-  }
-  return SWIG_TypeError;
-}
-}
-
-/* double */
-
-%fragment(SWIG_From_frag(double),"header") {
-  %define_as(SWIG_From_dec(double),  rb_float_new)
-}
-
-%fragment(SWIG_AsVal_frag(double),"header",fragment="SWIG_ruby_failed") {
-%ruby_aux_method(double, NUM2DBL, NUM2DBL(obj))
-
-SWIGINTERN int
-SWIG_AsVal_dec(double)(VALUE obj, double *val)
-{
-  VALUE type = TYPE(obj);
-  if ((type == T_FLOAT) || (type == T_FIXNUM) || (type == T_BIGNUM)) {
-    double v;
-    VALUE a[2];
-    a[0] = obj;
-    a[1] = (VALUE)(&v);
-    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2DBL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
-      if (val) *val = v;
-      return SWIG_OK;
-    }
-  }
-  return SWIG_TypeError;
-}
-}
-
-
diff --git a/share/swig/2.0.11/ruby/rubyrun.swg b/share/swig/2.0.11/ruby/rubyrun.swg
deleted file mode 100644
index e851b18..0000000
--- a/share/swig/2.0.11/ruby/rubyrun.swg
+++ /dev/null
@@ -1,441 +0,0 @@
-/* -----------------------------------------------------------------------------
- * rubyrun.swg
- *
- * This file contains the runtime support for Ruby modules
- * and includes code for managing global variables and pointer
- * type checking.
- * ----------------------------------------------------------------------------- */
-
-/* For backward compatibility only */
-#define SWIG_POINTER_EXCEPTION  0
-
-/* for raw pointers */
-#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
-#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
-#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
-#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
-#define swig_owntype                                    ruby_owntype
-
-/* for raw packed data */
-#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
-#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
-
-/* for class or struct pointers */
-#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
-#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
-
-/* for C or C++ function pointers */
-#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
-#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
-
-/* for C++ member pointers, ie, member methods */
-#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
-#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
-
-
-/* Runtime API */
-
-#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule(clientdata)
-#define SWIG_SetModule(clientdata, pointer) 		SWIG_Ruby_SetModule(pointer)
-
-
-/* Error manipulation */
-
-#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
-#define SWIG_Error(code, msg)            		rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
-#define SWIG_fail                        		goto fail				 
-
-
-/* Ruby-specific SWIG API */
-
-#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
-#define SWIG_define_class(ty)                        	SWIG_Ruby_define_class(ty)
-#define SWIG_NewClassInstance(value, ty)             	SWIG_Ruby_NewClassInstance(value, ty)
-#define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
-#define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  
-
-#include "assert.h"
-
-/* -----------------------------------------------------------------------------
- * pointers/data manipulation
- * ----------------------------------------------------------------------------- */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct {
-  VALUE klass;
-  VALUE mImpl;
-  void  (*mark)(void *);
-  void  (*destroy)(void *);
-  int trackObjects;
-} swig_class;
-
-
-/* Global pointer used to keep some internal SWIG stuff */
-static VALUE _cSWIG_Pointer = Qnil;
-static VALUE swig_runtime_data_type_pointer = Qnil;
-
-/* Global IDs used to keep some internal SWIG stuff */
-static ID swig_arity_id = 0;
-static ID swig_call_id  = 0;
-
-/*
-  If your swig extension is to be run within an embedded ruby and has
-  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
-  This will reset ruby's stack frame on each entry point from the main 
-  program the first time a virtual director function is invoked (in a 
-  non-recursive way).
-  If this is not done, you run the risk of Ruby trashing the stack.
-*/
-
-#ifdef RUBY_EMBEDDED
-
-#  define SWIG_INIT_STACK                            \
-      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
-      ++swig_virtual_calls;
-#  define SWIG_RELEASE_STACK --swig_virtual_calls;
-#  define Ruby_DirectorTypeMismatchException(x) \
-          rb_raise( rb_eTypeError, "%s", x ); return c_result;
-
-      static unsigned int swig_virtual_calls = 0;
-
-#else  /* normal non-embedded extension */
-
-#  define SWIG_INIT_STACK
-#  define SWIG_RELEASE_STACK
-#  define Ruby_DirectorTypeMismatchException(x) \
-          throw Swig::DirectorTypeMismatchException( x );
-
-#endif  /* RUBY_EMBEDDED */
-
-
-SWIGRUNTIME VALUE 
-getExceptionClass(void) {
-  static int init = 0;
-  static VALUE rubyExceptionClass ;
-  if (!init) {
-    init = 1;
-    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
-  }
-  return rubyExceptionClass;
-} 
-
-/* This code checks to see if the Ruby object being raised as part
-   of an exception inherits from the Ruby class Exception.  If so,
-   the object is simply returned.  If not, then a new Ruby exception
-   object is created and that will be returned to Ruby.*/
-SWIGRUNTIME VALUE
-SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
-  VALUE exceptionClass = getExceptionClass();
-  if (rb_obj_is_kind_of(obj, exceptionClass)) {
-    return obj;
-  }  else {
-    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
-  }
-}
-
-/* Initialize Ruby runtime support */
-SWIGRUNTIME void
-SWIG_Ruby_InitRuntime(void)
-{
-  if (_mSWIG == Qnil) {
-    _mSWIG = rb_define_module("SWIG");
-    swig_call_id  = rb_intern("call");
-    swig_arity_id = rb_intern("arity");
-  }
-}
-
-/* Define Ruby class for C type */
-SWIGRUNTIME void
-SWIG_Ruby_define_class(swig_type_info *type)
-{
-  VALUE klass;
-  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
-  sprintf(klass_name, "TYPE%s", type->name);
-  if (NIL_P(_cSWIG_Pointer)) {
-    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
-    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
-  }
-  klass = rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
-  free((void *) klass_name);
-}
-
-/* Create a new pointer object */
-SWIGRUNTIME VALUE
-SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
-{
-  int own =  flags & SWIG_POINTER_OWN; 
-  int track;
-  char *klass_name;
-  swig_class *sklass;
-  VALUE klass;
-  VALUE obj;
-  
-  if (!ptr)
-    return Qnil;
-  
-  if (type->clientdata) {
-    sklass = (swig_class *) type->clientdata;
-		
-    /* Are we tracking this class and have we already returned this Ruby object? */
-    track = sklass->trackObjects;
-    if (track) {
-      obj = SWIG_RubyInstanceFor(ptr);
-      
-      /* Check the object's type and make sure it has the correct type.
-        It might not in cases where methods do things like 
-        downcast methods. */
-      if (obj != Qnil) {
-        VALUE value = rb_iv_get(obj, "@__swigtype__");
-        const char* type_name = RSTRING_PTR(value);
-				
-        if (strcmp(type->name, type_name) == 0) {
-          return obj;
-        }
-      }
-    }
-
-    /* Create a new Ruby object */
-    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
-			   ( own ? VOIDFUNC(sklass->destroy) : 
-			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
-			     ), ptr);
-
-    /* If tracking is on for this class then track this object. */
-    if (track) {
-      SWIG_RubyAddTracking(ptr, obj);
-    }
-  } else {
-    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
-    sprintf(klass_name, "TYPE%s", type->name);
-    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
-    free((void *) klass_name);
-    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
-  }
-  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
-  
-  return obj;
-}
-
-/* Create a new class instance (always owned) */
-SWIGRUNTIME VALUE
-SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
-{
-  VALUE obj;
-  swig_class *sklass = (swig_class *) type->clientdata;
-  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
-  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
-  return obj;
-}
-
-/* Get type mangle from class name */
-SWIGRUNTIMEINLINE char *
-SWIG_Ruby_MangleStr(VALUE obj)
-{
-  VALUE stype = rb_iv_get(obj, "@__swigtype__");
-  return StringValuePtr(stype);
-}
-
-/* Acquire a pointer value */
-typedef void (*ruby_owntype)(void*);
-
-SWIGRUNTIME ruby_owntype
-SWIG_Ruby_AcquirePtr(VALUE obj, ruby_owntype own) {
-  if (obj) {
-    ruby_owntype oldown = RDATA(obj)->dfree;
-    RDATA(obj)->dfree = own;
-    return oldown;
-  } else {
-    return 0;
-  }
-}
-
-/* Convert a pointer value */
-SWIGRUNTIME int
-SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, ruby_owntype *own)
-{
-  char *c;
-  swig_cast_info *tc;
-  void *vptr = 0;
-
-  /* Grab the pointer */
-  if (NIL_P(obj)) {
-    *ptr = 0;
-    return SWIG_OK;
-  } else {
-    if (TYPE(obj) != T_DATA) {
-      return SWIG_ERROR;
-    }
-    Data_Get_Struct(obj, void, vptr);
-  }
-  
-  if (own) *own = RDATA(obj)->dfree;
-    
-  /* Check to see if the input object is giving up ownership
-     of the underlying C struct or C++ object.  If so then we
-     need to reset the destructor since the Ruby object no 
-     longer owns the underlying C++ object.*/ 
-  if (flags & SWIG_POINTER_DISOWN) {
-    /* Is tracking on for this class? */
-    int track = 0;
-    if (ty && ty->clientdata) {
-      swig_class *sklass = (swig_class *) ty->clientdata;
-      track = sklass->trackObjects;
-    }
-		
-    if (track) {
-      /* We are tracking objects for this class.  Thus we change the destructor
-       * to SWIG_RubyRemoveTracking.  This allows us to
-       * remove the mapping from the C++ to Ruby object
-       * when the Ruby object is garbage collected.  If we don't
-       * do this, then it is possible we will return a reference 
-       * to a Ruby object that no longer exists thereby crashing Ruby. */
-      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
-    } else {    
-      RDATA(obj)->dfree = 0;
-    }
-  }
-
-  /* Do type-checking if type info was provided */
-  if (ty) {
-    if (ty->clientdata) {
-      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
-        if (vptr == 0) {
-          /* The object has already been deleted */
-          return SWIG_ObjectPreviouslyDeletedError;
-        }
-        *ptr = vptr;
-        return SWIG_OK;
-      }
-    }
-    if ((c = SWIG_MangleStr(obj)) == NULL) {
-      return SWIG_ERROR;
-    }
-    tc = SWIG_TypeCheck(c, ty);
-    if (!tc) {
-      return SWIG_ERROR;
-    } else {
-      int newmemory = 0;
-      *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
-      assert(!newmemory); /* newmemory handling not yet implemented */
-    }
-  } else {
-    *ptr = vptr;
-  }
-  
-  return SWIG_OK;
-}
-
-/* Check convert */
-SWIGRUNTIMEINLINE int
-SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
-{
-  char *c = SWIG_MangleStr(obj);
-  if (!c) return 0;
-  return SWIG_TypeCheck(c,ty) != 0;
-}
-
-SWIGRUNTIME VALUE
-SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
-  char result[1024];
-  char *r = result;
-  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
-  *(r++) = '_';
-  r = SWIG_PackData(r, ptr, sz);
-  strcpy(r, type->name);
-  return rb_str_new2(result);
-}
-
-/* Convert a packed value value */
-SWIGRUNTIME int
-SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
-  swig_cast_info *tc;
-  const char  *c;
-
-  if (TYPE(obj) != T_STRING) goto type_error;
-  c = StringValuePtr(obj);
-  /* Pointer values must start with leading underscore */
-  if (*c != '_') goto type_error;
-  c++;
-  c = SWIG_UnpackData(c, ptr, sz);
-  if (ty) {
-    tc = SWIG_TypeCheck(c, ty);
-    if (!tc) goto type_error;
-  }
-  return SWIG_OK;
-
- type_error:
-  return SWIG_ERROR;
-}
-
-SWIGRUNTIME swig_module_info *
-SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
-{
-  VALUE pointer;
-  swig_module_info *ret = 0;
-  VALUE verbose = rb_gv_get("VERBOSE");
-
- /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
-  rb_gv_set("VERBOSE", Qfalse);
-  
-  /* first check if pointer already created */
-  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
-  if (pointer != Qnil) {
-    Data_Get_Struct(pointer, swig_module_info, ret);
-  }
-
-  /* reinstate warnings */
-  rb_gv_set("VERBOSE", verbose);
-  return ret;
-}
-
-SWIGRUNTIME void 
-SWIG_Ruby_SetModule(swig_module_info *pointer)
-{
-  /* register a new class */
-  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
-  /* create and store the structure pointer to a global variable */
-  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
-  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
-}
-
-/* This function can be used to check whether a proc or method or similarly
-   callable function has been passed.  Usually used in a %typecheck, like:
-
-   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
-        $result = SWIG_Ruby_isCallable( $input );
-   }
- */
-SWIGINTERN
-int SWIG_Ruby_isCallable( VALUE proc )
-{
-  if ( rb_respond_to( proc, swig_call_id ) )
-    return 1;
-  return 0;
-}
-
-/* This function can be used to check the arity (number of arguments)
-   a proc or method can take.  Usually used in a %typecheck.
-   Valid arities will be that equal to minimal or those < 0
-   which indicate a variable number of parameters at the end.
- */
-SWIGINTERN
-int SWIG_Ruby_arity( VALUE proc, int minimal )
-{
-  if ( rb_respond_to( proc, swig_arity_id ) )
-    {
-      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
-      int arity = NUM2INT(num);
-      if ( arity < 0 && (arity+1) < -minimal ) return 1;
-      if ( arity == minimal ) return 1;
-      return 1;
-    }
-  return 0;
-}
-
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/share/swig/2.0.11/ruby/rubystdcommon.swg b/share/swig/2.0.11/ruby/rubystdcommon.swg
deleted file mode 100644
index b4ae3a3..0000000
--- a/share/swig/2.0.11/ruby/rubystdcommon.swg
+++ /dev/null
@@ -1,202 +0,0 @@
-
-/* ------------------------------------------------------------
- * The Ruby classes, for C++
- * ------------------------------------------------------------ */
-%include <rubyclasses.swg>
-
-%fragment("StdTraits","header",fragment="StdTraitsCommon")
-{
-
-namespace swig {  
-  /*
-    Traits that provides the from method
-  */
-  template <class Type> struct traits_from_ptr {
-    static VALUE from(Type *val, int owner = 0) {
-      return SWIG_NewPointerObj(val, type_info<Type>(), owner);
-    }
-  };
-
-  template <class Type> struct traits_from {
-    static VALUE from(const Type& val) {
-      return traits_from_ptr<Type>::from(new Type(val), 1);
-    }
-  };
-
-  template <class Type> struct traits_from<Type *> {
-    static VALUE from(Type* val) {
-      return traits_from_ptr<Type>::from(val, 0);
-    }
-  };
-
-  template <class Type> struct traits_from<const Type *> {
-    static VALUE from(const Type* val) {
-      return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
-    }
-  };
-
-
-  template <class Type>
-  inline VALUE from(const Type& val) {
-    return traits_from<Type>::from(val);
-  }
-
-  template <class Type>
-  inline VALUE from_ptr(Type* val, int owner) {
-    return traits_from_ptr<Type>::from(val, owner);
-  }
-
-  /*
-    Traits that provides the asval/as/check method
-  */
-  template <class Type>
-  struct traits_asptr {   
-    static int asptr(VALUE obj, Type **val) {
-      Type *p;
-      int res = SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0);
-      if (SWIG_IsOK(res)) {
-	if (val) *val = p;
-      }
-      return res;
-    }
-  }; 
-
-  template <class Type>
-  inline int asptr(VALUE obj, Type **vptr) {
-    return traits_asptr<Type>::asptr(obj, vptr);
-  }
-
-  template <class Type> 
-  struct traits_asval {
-    static int asval(VALUE obj, Type *val) {
-      if (val) {
-	Type *p = 0;
-	int res = traits_asptr<Type>::asptr(obj, &p);
-	if (!SWIG_IsOK(res)) return res;	
-	if (p) {
-	  typedef typename noconst_traits<Type>::noconst_type noconst_type;
-	  *(const_cast<noconst_type*>(val)) = *p;
-	  if (SWIG_IsNewObj(res)){
-	    %delete(p);
-	    res = SWIG_DelNewMask(res);
-	  }
-	  return res;
-	} else {
-	  return SWIG_ERROR;
-	}
-      } else {
-	return traits_asptr<Type>::asptr(obj, (Type **)(0));
-      }
-    }
-  };
-
-  template <class Type> struct traits_asval<Type*> {
-    static int asval(VALUE obj, Type **val) {
-      if (val) {
-        typedef typename noconst_traits<Type>::noconst_type noconst_type;
-        noconst_type *p = 0;
-        int res = traits_asptr<noconst_type>::asptr(obj,  &p);
-        if (SWIG_IsOK(res)) {
-          *(const_cast<noconst_type**>(val)) = p;
-	}
-	return res;
-      } else {
-	return traits_asptr<Type>::asptr(obj, (Type **)(0));
-      }
-    }
-  };
-  
-  template <class Type>
-  inline int asval(VALUE obj, Type *val) {
-    return traits_asval<Type>::asval(obj, val);
-  }
-
-  template <class Type> 
-  struct traits_as<Type, value_category> {
-    static Type as(VALUE obj, bool throw_error) {
-      Type v;
-      int res = asval(obj, &v);
-      if (!obj || !SWIG_IsOK(res)) {
-	if (throw_error) throw std::invalid_argument("bad type");
-	VALUE lastErr = rb_gv_get("$!");
-	if (lastErr == Qnil) {
-	  %type_error(swig::type_name<Type>());
-	}
-      }
-      return v;
-    }
-  };
-
-  template <class Type> 
-  struct traits_as<Type, pointer_category> {
-    static Type as(VALUE obj, bool throw_error) {
-      Type *v = 0;      
-      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
-      if (SWIG_IsOK(res) && v) {
-	if (SWIG_IsNewObj(res)) {
-	  Type r(*v);
-	  %delete(v);
-	  return r;
-	} else {
-	  return *v;
-	}
-      } else {
-	// Uninitialized return value, no Type() constructor required.
-	if (throw_error) throw std::invalid_argument("bad type");
-	VALUE lastErr = rb_gv_get("$!");
-	if (lastErr == Qnil) {
-	  %type_error(swig::type_name<Type>());
-	}
-	static Type *v_def = (Type*) malloc(sizeof(Type));
-	memset(v_def,0,sizeof(Type));
-	return *v_def;
-      }
-    }
-  };
-
-  template <class Type> 
-  struct traits_as<Type*, pointer_category> {
-    static Type* as(VALUE obj, bool throw_error) {
-      Type *v = 0;      
-      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
-      if (SWIG_IsOK(res)) {
-	return v;
-      } else {
-	if (throw_error) throw std::invalid_argument("bad type");
-	VALUE lastErr = rb_gv_get("$!");
-	if (lastErr == Qnil) {
-	  %type_error(swig::type_name<Type>());
-	}
-	return 0;
-      }
-    }
-  };
-
-  template <class Type>
-  inline Type as(VALUE obj, bool te = false) {
-    return traits_as< Type, typename traits< Type >::category >::as(obj, te);
-  }
-
-  template <class Type> 
-  struct traits_check<Type, value_category> {
-    static bool check(VALUE obj) {
-      int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
-      return SWIG_IsOK(res) ? true : false;
-    }
-  };
-
-  template <class Type> 
-  struct traits_check<Type, pointer_category> {
-    static bool check(VALUE obj) {
-      int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
-      return SWIG_IsOK(res) ? true : false;
-    }
-  };
-
-  template <class Type>
-  inline bool check(VALUE obj) {
-    return traits_check<Type, typename traits<Type>::category>::check(obj);
-  }
-}
-}
-
diff --git a/share/swig/2.0.11/ruby/rubystdfunctors.swg b/share/swig/2.0.11/ruby/rubystdfunctors.swg
deleted file mode 100644
index f2050b6..0000000
--- a/share/swig/2.0.11/ruby/rubystdfunctors.swg
+++ /dev/null
@@ -1,162 +0,0 @@
-/**
- * @file   rubystdfunctors.swg
- * @date   Sun May  6 00:44:33 2007
- * 
- * @brief  This file provides unary and binary functors for STL
- *         containers, that will invoke a Ruby proc or method to do
- *         their operation.
- *
- *         You can use them in a swig file like:
- *
- *         %include <std_set.i>
- *         %include <std_functors.i>
- *
- *         %template< IntSet > std::set< int, swig::BinaryPredicate<> >;
- *
- *
- *         which will then allow calling them from Ruby either like:
- *  
- *            # order of set is defined by C++ default
- *            a = IntSet.new
- *
- *            # sort order defined by Ruby proc
- *            b = IntSet.new( proc { |a,b| a > b } )
- * 
- */
-
-%include rubyclasses.swg
-
-
-namespace swig {
-
-  %apply GC_VALUE { UnaryPredicate, BinaryPredicate, UnaryFunction,
-		      BinaryFunction };
-
-  %typecheck(SWIG_TYPECHECK_POINTER,noblock=1) 
-    UnaryPredicate, UnaryPredicate&, UnaryFunction, UnaryFunction&
-  {
-    $1 = SWIG_Ruby_isCallable($input) && SWIG_Ruby_arity($input, 1);
-  }
-
-  %typecheck(SWIG_TYPECHECK_POINTER,noblock=1) 
-    BinaryPredicate, BinaryPredicate&, BinaryFunction, BinaryFunction& {
-    $1 = SWIG_Ruby_isCallable($input) && SWIG_Ruby_arity($input, 2);
-  }
-
-  %typemap(in,noblock=1)  BinaryFunction&, BinaryFunction {
-    $1 = new swig::BinaryFunction< >($input);
-  }
-  %typemap(in,noblock=1) UnaryFunction&, UnaryFunction {
-    $1 = new swig::UnaryFunction< >($input);
-  }
-
-  %typemap(in,noblock=1) BinaryPredicate&, BinaryPredicate {
-    $1 = new swig::BinaryPredicate<>($input);
-  }
-
-  %typemap(in,noblock=1) UnaryPredicate&, UnaryPredicate {
-    $1 = new swig::UnaryPredicate< >($input);
-  }
-
-
-  %ignore BinaryFunction;
-  template< class _T = GC_VALUE >
-  struct BinaryFunction {
-  };
-
-  %ignore UnaryFunction;
-  template< class _T = GC_VALUE >
-  struct UnaryFunction {
-  };
-
-  %ignore BinaryPredicate;
-  template< class _T = GC_VALUE >
-  struct BinaryPredicate {
-  };
-
-  %ignore UnaryPredicate;
-  template< class _T = GC_VALUE >
-  struct UnaryPredicate {
-
-  };
-
-}
-
-
-%fragment("StdFunctors","header",fragment="StdTraits",fragment="GC_VALUE_definition")
-{
-namespace swig {
-
-  static ID call_id = rb_intern("call");
-
-  template <class _T = GC_VALUE, class _DefaultFunc = std::less<GC_VALUE> >
-  struct BinaryPredicate : GC_VALUE, std::binary_function< _T, _T, bool >
-  {
-    BinaryPredicate(VALUE obj = Qnil) : GC_VALUE(obj) { }
-    bool operator()(_T a, _T b) const
-    {
-      if (_obj != Qnil) {
-        SWIG_RUBY_THREAD_BEGIN_BLOCK;
-	VALUE arg1 = swig::from(a);
-	VALUE arg2 = swig::from(b);
-	VALUE res = rb_funcall( _obj, swig::call_id, 2, arg1, arg2);
-        SWIG_RUBY_THREAD_END_BLOCK;
-        return RTEST(res);
-      } else {
-        return _DefaultFunc()(a, b);
-      }
-    }
-  };
-
-  template <class _T = GC_VALUE, class _DefaultFunc = std::less< _T > >
-  struct BinaryFunction : GC_VALUE, std::binary_function< _T, _T, _T >
-  {
-    BinaryFunction(VALUE obj = Qnil) : GC_VALUE(obj) { }
-    _T operator()(_T a, _T b) const
-    {
-      if (_obj != Qnil) {
-        SWIG_RUBY_THREAD_BEGIN_BLOCK;
-	VALUE arg1 = swig::from(a);
-	VALUE arg2 = swig::from(b);
-	VALUE res = rb_funcall( _obj, swig::call_id, 2, arg1, arg2);
-        SWIG_RUBY_THREAD_END_BLOCK;
-        return swig::as<_T >(res);
-      } else {
-        return _DefaultFunc()(a, b);
-      }
-    }
-  };
-
-  template< class _T = GC_VALUE >
-  struct UnaryPredicate : GC_VALUE, std::unary_function< _T, bool >
-  {
-    UnaryPredicate(VALUE obj = Qnil) : GC_VALUE(obj) { }
-    bool operator()(_T a) const
-    {
-      SWIG_RUBY_THREAD_BEGIN_BLOCK;
-      VALUE arg1 = swig::from<_T >(a);
-      VALUE res = rb_funcall( _obj, swig::call_id, 1, arg1);
-      SWIG_RUBY_THREAD_END_BLOCK;
-      return RTEST(res);
-    }
-  };
-
-  template< class _T = GC_VALUE >
-  struct UnaryFunction : GC_VALUE, std::unary_function< _T, _T >
-  {
-    UnaryFunction(VALUE obj = Qnil) : GC_VALUE(obj) { }
-    _T operator()(_T a) const
-    {
-      SWIG_RUBY_THREAD_BEGIN_BLOCK;
-      VALUE arg1 = swig::from(a);
-      VALUE res = rb_funcall( _obj, swig::call_id, 1, VALUE(arg1));
-      SWIG_RUBY_THREAD_END_BLOCK;
-      return swig::as< _T >(res);
-    }
-  };
-
-} // namespace swig
-
-}
-
-
diff --git a/share/swig/2.0.11/ruby/rubytracking.swg b/share/swig/2.0.11/ruby/rubytracking.swg
deleted file mode 100644
index 0a36f4a..0000000
--- a/share/swig/2.0.11/ruby/rubytracking.swg
+++ /dev/null
@@ -1,157 +0,0 @@
-/* -----------------------------------------------------------------------------
- * rubytracking.swg
- *
- * This file contains support for tracking mappings from 
- * Ruby objects to C++ objects.  This functionality is needed
- * to implement mark functions for Ruby's mark and sweep
- * garbage collector.
- * ----------------------------------------------------------------------------- */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Ruby 1.8 actually assumes the first case. */
-#if SIZEOF_VOIDP == SIZEOF_LONG
-#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
-#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
-#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
-#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
-#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
-#else
-#  error sizeof(void*) is not the same as long or long long
-#endif
-
-
-/* Global Ruby hash table to store Trackings from C/C++
-   structs to Ruby Objects. 
-*/
-static VALUE swig_ruby_trackings = Qnil;
-
-/* Global variable that stores a reference to the ruby
-   hash table delete function. */
-static ID swig_ruby_hash_delete;
-
-/* Setup a Ruby hash table to store Trackings */
-SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
-  /* Create a ruby hash table to store Trackings from C++ 
-     objects to Ruby objects. */
-
-  /* Try to see if some other .so has already created a 
-     tracking hash table, which we keep hidden in an instance var
-     in the SWIG module.
-     This is done to allow multiple DSOs to share the same
-     tracking table.
-  */
-  ID trackings_id = rb_intern( "@__trackings__" );
-  VALUE verbose = rb_gv_get("VERBOSE");
-  rb_gv_set("VERBOSE", Qfalse);
-  swig_ruby_trackings = rb_ivar_get( _mSWIG, trackings_id );
-  rb_gv_set("VERBOSE", verbose);
-
-  /* No, it hasn't.  Create one ourselves */ 
-  if ( swig_ruby_trackings == Qnil )
-    {
-      swig_ruby_trackings = rb_hash_new();
-      rb_ivar_set( _mSWIG, trackings_id, swig_ruby_trackings );
-    }
-
-  /* Now store a reference to the hash table delete function
-     so that we only have to look it up once.*/
-  swig_ruby_hash_delete = rb_intern("delete");
-}
-
-/* Get a Ruby number to reference a pointer */
-SWIGRUNTIME VALUE SWIG_RubyPtrToReference(void* ptr) {
-  /* We cast the pointer to an unsigned long
-     and then store a reference to it using
-     a Ruby number object. */
-
-  /* Convert the pointer to a Ruby number */
-  return SWIG2NUM(ptr);
-}
-
-/* Get a Ruby number to reference an object */
-SWIGRUNTIME VALUE SWIG_RubyObjectToReference(VALUE object) {
-  /* We cast the object to an unsigned long
-     and then store a reference to it using
-     a Ruby number object. */
-
-  /* Convert the Object to a Ruby number */
-  return SWIG2NUM(object);
-}
-
-/* Get a Ruby object from a previously stored reference */
-SWIGRUNTIME VALUE SWIG_RubyReferenceToObject(VALUE reference) {
-  /* The provided Ruby number object is a reference
-     to the Ruby object we want.*/
-
-  /* Convert the Ruby number to a Ruby object */
-  return NUM2SWIG(reference);
-}
-
-/* Add a Tracking from a C/C++ struct to a Ruby object */
-SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
-  /* In a Ruby hash table we store the pointer and
-     the associated Ruby object.  The trick here is
-     that we cannot store the Ruby object directly - if
-     we do then it cannot be garbage collected.  So
-     instead we typecast it as a unsigned long and
-     convert it to a Ruby number object.*/
-
-  /* Get a reference to the pointer as a Ruby number */
-  VALUE key = SWIG_RubyPtrToReference(ptr);
-
-  /* Get a reference to the Ruby object as a Ruby number */
-  VALUE value = SWIG_RubyObjectToReference(object);
-
-  /* Store the mapping to the global hash table. */
-  rb_hash_aset(swig_ruby_trackings, key, value);
-}
-
-/* Get the Ruby object that owns the specified C/C++ struct */
-SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
-  /* Get a reference to the pointer as a Ruby number */
-  VALUE key = SWIG_RubyPtrToReference(ptr);
-
-  /* Now lookup the value stored in the global hash table */
-  VALUE value = rb_hash_aref(swig_ruby_trackings, key);
-	
-  if (value == Qnil) {
-    /* No object exists - return nil. */
-    return Qnil;
-  }
-  else {
-    /* Convert this value to Ruby object */
-    return SWIG_RubyReferenceToObject(value);
-  }
-}
-
-/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
-   is very important to remove objects once they are destroyed
-   since the same memory address may be reused later to create
-   a new object. */
-SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
-  /* Get a reference to the pointer as a Ruby number */
-  VALUE key = SWIG_RubyPtrToReference(ptr);
-
-  /* Delete the object from the hash table by calling Ruby's
-     do this we need to call the Hash.delete method.*/
-  rb_funcall(swig_ruby_trackings, swig_ruby_hash_delete, 1, key);
-}
-
-/* This is a helper method that unlinks a Ruby object from its
-   underlying C++ object.  This is needed if the lifetime of the
-   Ruby object is longer than the C++ object */
-SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
-  VALUE object = SWIG_RubyInstanceFor(ptr);
-
-  if (object != Qnil) {
-    DATA_PTR(object) = 0;
-  }
-}
-
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/share/swig/2.0.11/ruby/rubytypemaps.swg b/share/swig/2.0.11/ruby/rubytypemaps.swg
deleted file mode 100644
index 336ee97..0000000
--- a/share/swig/2.0.11/ruby/rubytypemaps.swg
+++ /dev/null
@@ -1,62 +0,0 @@
-/* ------------------------------------------------------------
- *  Typemap specializations for Ruby
- * ------------------------------------------------------------ */
-/* ------------------------------------------------------------
- *  Fragment section
- * ------------------------------------------------------------ */
-/* bool is dangerous in Ruby, change precedence */
-#undef SWIG_TYPECHECK_BOOL
-%define SWIG_TYPECHECK_BOOL             10000 %enddef
-
-/* Include fundamental fragemt definitions */
-%include <typemaps/fragments.swg>
-
-/* Look for user fragments file. */
-%include <rubyfragments.swg>
-
-/* Ruby fragments for primitive types */
-%include <rubyprimtypes.swg>
-
-/* Ruby fragments for char* strings */
-%include <rubystrings.swg>
-
-/* Backward compatibility output helper */
-%fragment("output_helper","header") %{
-#define output_helper SWIG_Ruby_AppendOutput
-%}
-
-/* ------------------------------------------------------------
- *  Unified typemap section
- * ------------------------------------------------------------ */
-
-/* Directors are supported in Ruby */
-#ifndef SWIG_DIRECTOR_TYPEMAPS
-#define SWIG_DIRECTOR_TYPEMAPS
-#endif
-
-
-/* Ruby types */
-#define SWIG_Object                      VALUE
-#define VOID_Object                      Qnil
-
-/* Overload of the output/constant/exception handling */
-
-/* append output */
-#define SWIG_AppendOutput(result,obj)    SWIG_Ruby_AppendOutput(result, obj)
-
-/* set constant */
-#define SWIG_SetConstant(name, obj)      rb_define_const($module, name, obj)
-
-/* raise */
-#define SWIG_Raise(obj, type, desc)      rb_exc_raise(SWIG_Ruby_ExceptionType(desc, obj)) 
-
-/* Get the address of the 'Ruby self' object */
-
-%typemap(in,numinputs=0,noblock=1) VALUE* RUBY_SELF {
-  $1 = &self;
-}
-
-/* Include the unified typemap library */
-%include <typemaps/swigtypemaps.swg>
-
-
diff --git a/share/swig/2.0.11/ruby/rubywstrings.swg b/share/swig/2.0.11/ruby/rubywstrings.swg
deleted file mode 100644
index bb44fbc..0000000
--- a/share/swig/2.0.11/ruby/rubywstrings.swg
+++ /dev/null
@@ -1,72 +0,0 @@
-/* -----------------------------------------------------------------------------
- * rubywstrings.swg
- *
- * Currently, Ruby does not support Unicode or WChar properly, so these
- * are still treated as char arrays for now.
- * There are other libraries available that add support to this in
- * ruby including WString, FXString, etc.
- * ----------------------------------------------------------------------------- */
-
-/* ------------------------------------------------------------
- *  utility methods for wchar_t strings 
- * ------------------------------------------------------------ */
-
-%fragment("SWIG_AsWCharPtrAndSize","header",fragment="<wchar.h>",fragment="SWIG_pwchar_descriptor") {
-SWIGINTERN int
-SWIG_AsWCharPtrAndSize(VALUE obj, wchar_t **cptr, size_t *psize, int *alloc)
-{
-  return SWIG_AsCharPtrAndSize( obj, (char**)cptr, psize, alloc);
-//   VALUE tmp = 0;
-//   bool ok = false;
-//   if ( TYPE(obj) == T_STRING ) {
-//     if (cptr) {
-//       obj = tmp = SWIG_Unicode_FromObject(obj);
-//       ok = true;
-//     }
-//   }
-//   if (ok) {
-//     Py_ssize_t len = PyUnicode_GetSize(obj);
-//     rb_notimplement();
-//     if (cptr) {
-//       *cptr = %new_array(len + 1, wchar_t);
-//       SWIG_Unicode_AsWideChar((PyUnicodeObject *)obj, *cptr, len);
-//       (*cptr)[len] = 0;
-//     }
-//     if (psize) *psize = (size_t) len + 1;
-//     if (alloc) *alloc = cptr ? SWIG_NEWOBJ : 0;
-//     return SWIG_OK;
-//   } else {
-//     swig_type_info* pwchar_descriptor = SWIG_pwchar_descriptor();
-//     if (pwchar_descriptor) {
-//       void * vptr = 0;
-//       if (SWIG_ConvertPtr(obj, &vptr, pwchar_descriptor, 0) == SWIG_OK) {
-// 	if (cptr) *cptr = (wchar_t *)vptr;
-// 	if (psize) *psize = vptr ? (wcslen((wchar_t *)vptr) + 1) : 0;
-// 	return SWIG_OK;
-//       }
-//     }
-//   }
-//   return SWIG_TypeError;
-}
-}
-
-%fragment("SWIG_FromWCharPtrAndSize","header",fragment="<wchar.h>",fragment="SWIG_pwchar_descriptor") {
-SWIGINTERNINLINE VALUE 
-SWIG_FromWCharPtrAndSize(const wchar_t * carray, size_t size)
-{
-  return SWIG_FromCharPtrAndSize( (const char*)carray, size);
-//   if (carray) {
-//     if (size > INT_MAX) {
-//       swig_type_info* pwchar_descriptor = SWIG_pwchar_descriptor();
-//       return pwchar_descriptor ? 
-// 	SWIG_NewPointerObj(%const_cast(carray,wchar_t *), pwchar_descriptor, 0) : Qnil;
-//     } else {
-//       return SWIG_Unicode_FromWideChar(carray, %numeric_cast(size,int));
-//     }
-//   } else {
-//     return Qnil;
-//   }
-}
-}
-
-
diff --git a/share/swig/2.0.11/ruby/std_common.i b/share/swig/2.0.11/ruby/std_common.i
deleted file mode 100644
index 14fba0d..0000000
--- a/share/swig/2.0.11/ruby/std_common.i
+++ /dev/null
@@ -1,74 +0,0 @@
-%include <std/std_except.i>
-%include <rubystdcommon.swg>
-%include <rubystdautodoc.swg>
-
-
-/*
-  Generate the traits for a 'primitive' type, such as 'double',
-  for which the SWIG_AsVal and SWIG_From methods are already defined.
-*/
-
-%define %traits_ptypen(Type...)
-  %fragment(SWIG_Traits_frag(Type),"header",
-	    fragment=SWIG_AsVal_frag(Type),
-	    fragment=SWIG_From_frag(Type),
-	    fragment="StdTraits") {
-namespace swig {
-  template <> struct traits<Type > {
-    typedef value_category category;
-    static const char* type_name() { return  #Type; }
-  };  
-  template <>  struct traits_asval<Type > {   
-    typedef Type value_type;
-    static int asval(VALUE obj, value_type *val) { 
-      return SWIG_AsVal(Type)(obj, val);
-    }
-  };
-  template <>  struct traits_from<Type > {
-    typedef Type value_type;
-    static VALUE from(const value_type& val) {
-      return SWIG_From(Type)(val);
-    }
-  };
-}
-}
-%enddef
-
-/* Traits for enums. This is bit of a sneaky trick needed because a generic template specialization of enums
-   is not possible (unless using template meta-programming which SWIG doesn't support because of the explicit
-   instantiations required using %template). The STL containers define the 'front' method and the typemap
-   below is used whenever the front method is wrapped returning an enum. This typemap simply picks up the
-   standard enum typemap, but additionally drags in a fragment containing the traits_asval and traits_from
-   required in the generated code for enums. */
-
-%define %traits_enum(Type...)
-  %fragment("SWIG_Traits_enum_"{Type},"header",
-	    fragment=SWIG_AsVal_frag(int),
-	    fragment=SWIG_From_frag(int),
-	    fragment="StdTraits") {
-namespace swig {
-  template <>  struct traits_asval<Type > {   
-    typedef Type value_type;
-    static int asval(VALUE obj, value_type *val) { 
-      return SWIG_AsVal(int)(obj, (int *)val);
-    }
-  };
-  template <>  struct traits_from<Type > {
-    typedef Type value_type;
-    static VALUE from(const value_type& val) {
-      return SWIG_From(int)((int)val);
-    }
-  };
-}
-}
-%typemap(out, fragment="SWIG_Traits_enum_"{Type}) const enum SWIGTYPE& front %{$typemap(out, const enum SWIGTYPE&)%}
-%enddef
-
-
-%include <std/std_common.i>
-
-//
-// Generates the traits for all the known primitive
-// C++ types (int, double, ...)
-//
-%apply_cpptypes(%traits_ptypen);
diff --git a/share/swig/2.0.11/ruby/std_map.i b/share/swig/2.0.11/ruby/std_map.i
deleted file mode 100644
index f706ca8..0000000
--- a/share/swig/2.0.11/ruby/std_map.i
+++ /dev/null
@@ -1,423 +0,0 @@
-//
-//   Maps
-//
-%fragment("StdMapCommonTraits","header",fragment="StdSequenceTraits")
-{
-  namespace swig {
-    template <class ValueType>
-    struct from_key_oper 
-    {
-      typedef const ValueType& argument_type;
-      typedef  VALUE result_type;
-      result_type operator()(argument_type v) const
-      {
-	return swig::from(v.first);
-      }
-    };
-
-    template <class ValueType>
-    struct from_value_oper 
-    {
-      typedef const ValueType& argument_type;
-      typedef  VALUE result_type;
-      result_type operator()(argument_type v) const
-      {
-	return swig::from(v.second);
-      }
-    };
-
-    template<class OutIterator, class FromOper, 
-	     class ValueType = typename OutIterator::value_type>
-    struct MapIterator_T : ConstIteratorClosed_T<OutIterator, ValueType, FromOper>
-    {
-      MapIterator_T(OutIterator curr, OutIterator first, OutIterator last, VALUE seq)
-	: ConstIteratorClosed_T<OutIterator,ValueType,FromOper>(curr, first, last, seq)
-      {
-      }
-    };
-
-
-    template<class OutIterator,
-	     class FromOper = from_key_oper<typename OutIterator::value_type> >
-    struct MapKeyIterator_T : MapIterator_T<OutIterator, FromOper>
-    {
-      MapKeyIterator_T(OutIterator curr, OutIterator first, OutIterator last, VALUE seq)
-	: MapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
-      {
-      }
-    };
-
-    template<typename OutIter>
-    inline ConstIterator*
-    make_output_key_iterator(const OutIter& current, const OutIter& begin, 
-			     const OutIter& end, VALUE seq = 0)
-    {
-      return new MapKeyIterator_T<OutIter>(current, begin, end, seq);
-    }
-
-    template<class OutIterator,
-	     class FromOper = from_value_oper<typename OutIterator::value_type> >
-    struct MapValueIterator_T : MapIterator_T<OutIterator, FromOper>
-    {
-      MapValueIterator_T(OutIterator curr, OutIterator first, OutIterator last, VALUE seq)
-	: MapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
-      {
-      }
-    };
-    
-
-    template<typename OutIter>
-    inline ConstIterator*
-    make_output_value_iterator(const OutIter& current, const OutIter& begin, 
-			       const OutIter& end, VALUE seq = 0)
-    {
-      return new MapValueIterator_T<OutIter>(current, begin, end, seq);
-    }
-  }
-}
-
-%fragment("StdMapTraits","header",fragment="StdMapCommonTraits")
-{
-  namespace swig {
-    template <class RubySeq, class K, class T >
-    inline void
-    assign(const RubySeq& rubyseq, std::map<K,T > *map) {
-      typedef typename std::map<K,T>::value_type value_type;
-      typename RubySeq::const_iterator it = rubyseq.begin();
-      for (;it != rubyseq.end(); ++it) {
-	map->insert(value_type(it->first, it->second));
-      }
-    }
-
-    template <class K, class T>
-    struct traits_asptr<std::map<K,T> >  {
-      typedef std::map<K,T> map_type;
-      static int asptr(VALUE obj, map_type **val) {
-	int res = SWIG_ERROR;
-	if ( TYPE(obj) == T_HASH ) {
-	  static ID id_to_a = rb_intern("to_a");
-	  VALUE items = rb_funcall(obj, id_to_a, 0);
-	  res = traits_asptr_stdseq<std::map<K,T>, std::pair<K, T> >::asptr(items, val);
-	} else {
-	  map_type *p;
-	  res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<map_type>(),0);
-	  if (SWIG_IsOK(res) && val)  *val = p;
-	}
-	return res;
-      }
-    };
-      
-    template <class K, class T >
-    struct traits_from<std::map<K,T> >  {
-      typedef std::map<K,T> map_type;
-      typedef typename map_type::const_iterator const_iterator;
-      typedef typename map_type::size_type size_type;
-            
-      static VALUE from(const map_type& map) {
-	swig_type_info *desc = swig::type_info<map_type>();
-	if (desc && desc->clientdata) {
-	  return SWIG_NewPointerObj(new map_type(map), desc, SWIG_POINTER_OWN);
-	} else {
-	  size_type size = map.size();
-	  int rubysize = (size <= (size_type) INT_MAX) ? (int) size : -1;
-	  if (rubysize < 0) {
-	    SWIG_RUBY_THREAD_BEGIN_BLOCK;
-	    rb_raise( rb_eRuntimeError, "map size not valid in Ruby");
-	    SWIG_RUBY_THREAD_END_BLOCK;
-	    return Qnil;
-	  }
-	  VALUE obj = rb_hash_new();
-	  for (const_iterator i= map.begin(); i!= map.end(); ++i) {
-	    VALUE key = swig::from(i->first);
-	    VALUE val = swig::from(i->second);
-	    rb_hash_aset(obj, key, val);
-	  }
-	  return obj;
-	}
-      }
-    };
-  }
-}
-
-%define %swig_map_common(Map...)
-  %swig_container_methods(%arg(Map));
-  // %swig_sequence_iterator(%arg(Map));
-
-  %extend {
-    
-    VALUE __delete__(const key_type& key) {
-      Map::iterator i = self->find(key);
-      if (i != self->end()) {
-	self->erase(i);
-	return swig::from( key );
-      }
-      else {
-	return Qnil;
-      }
-    }
-    
-    bool has_key(const key_type& key) const {
-      Map::const_iterator i = self->find(key);
-      return i != self->end();
-    }
-    
-    VALUE keys() {
-      Map::size_type size = self->size();
-      int rubysize = (size <= (Map::size_type) INT_MAX) ? (int) size : -1;
-      if (rubysize < 0) {
-	SWIG_RUBY_THREAD_BEGIN_BLOCK;
-	rb_raise(rb_eRuntimeError, "map size not valid in Ruby");
-	SWIG_RUBY_THREAD_END_BLOCK;
-	return Qnil;
-      }
-      VALUE ary = rb_ary_new2(rubysize);
-      Map::const_iterator i = self->begin();
-      Map::const_iterator e = self->end();
-      for ( ; i != e; ++i ) {
-	rb_ary_push( ary, swig::from(i->first) );
-      }
-      return ary;
-    }
-
-    Map* each()
-      {
-	if ( !rb_block_given_p() )
-	  rb_raise( rb_eArgError, "no block given");
-
-	VALUE k, v;
-	Map::iterator i = self->begin();
-	Map::iterator e = self->end();
-	for ( ; i != e; ++i )
-	  {
-	    const Map::key_type&    key = i->first;
-	    const Map::mapped_type& val = i->second;
-
-	    k = swig::from<Map::key_type>(key);
-	    v = swig::from<Map::mapped_type>(val);
-	    rb_yield_values(2, k, v);
-	  }
-	
-	return self;
-      }
-
-    %newobject select;
-    Map* select() {
-      if ( !rb_block_given_p() )
-	rb_raise( rb_eArgError, "no block given" );
-
-      Map* r = new Map;
-      Map::iterator i = $self->begin();
-      Map::iterator e = $self->end();
-      for ( ; i != e; ++i )
-	{
-	  VALUE k = swig::from<Map::key_type>(i->first);
-	  VALUE v = swig::from<Map::mapped_type>(i->second);
-	  if ( RTEST( rb_yield_values(2, k, v) ) )
-	    $self->insert(r->end(), *i);
-	}
-	
-      return r;
-    }
-
-  %typemap(in) (int argc, VALUE* argv) {
-    $1 = argc;
-    $2 = argv;
-  }
-
-  VALUE values_at(int argc, VALUE* argv, ...) {
-    
-    VALUE r = rb_ary_new();
-    ID   id = rb_intern("[]");
-    swig_type_info* type = swig::type_info< Map >();
-    VALUE me = SWIG_NewPointerObj( $self, type, 0 );
-    for ( int i = 0; i < argc; ++i )
-      {
-	VALUE key = argv[i];
-	VALUE tmp = rb_funcall( me, id, 1, key );
-	rb_ary_push( r, tmp );
-      }
-    
-    return r;
-  }
-
-
-    Map* each_key()
-      {
-	if ( !rb_block_given_p() )
-	  rb_raise( rb_eArgError, "no block given");
-
-	VALUE r;
-	Map::iterator i = self->begin();
-	Map::iterator e = self->end();
-	for ( ; i != e; ++i )
-	  {
-	    r = swig::from( i->first );
-	    rb_yield(r);
-	  }
-	
-	return self;
-      }
-    
-    VALUE values() {
-      Map::size_type size = self->size();
-      int rubysize = (size <= (Map::size_type) INT_MAX) ? (int) size : -1;
-      if (rubysize < 0) {
-	SWIG_RUBY_THREAD_BEGIN_BLOCK;
-	rb_raise(rb_eRuntimeError, "map size not valid in Ruby");
-	SWIG_RUBY_THREAD_END_BLOCK;
-	return Qnil;
-      }
-      VALUE ary = rb_ary_new2(rubysize);
-      Map::const_iterator i = self->begin();
-      Map::const_iterator e = self->end();
-      for ( ; i != e; ++i ) {
-	rb_ary_push( ary, swig::from(i->second) );
-      }
-      return ary;
-    }
-    
-    Map* each_value()
-      {
-	if ( !rb_block_given_p() )
-	  rb_raise( rb_eArgError, "no block given");
-
-	VALUE r;
-	Map::iterator i = self->begin();
-	Map::iterator e = self->end();
-	for ( ; i != e; ++i )
-	  {
-	    r = swig::from( i->second );
-	    rb_yield(r);
-	  }
-	
-	return self;
-      }
-
-    VALUE entries() {
-      Map::size_type size = self->size();
-      int rubysize = (size <= (Map::size_type) INT_MAX) ? (int) size : -1;
-      if (rubysize < 0) {
-	SWIG_RUBY_THREAD_BEGIN_BLOCK;
-	rb_raise(rb_eRuntimeError, "map size not valid in Ruby");
-	SWIG_RUBY_THREAD_END_BLOCK;
-	return Qnil;
-      }
-      VALUE ary = rb_ary_new2(rubysize);
-      Map::const_iterator i = self->begin();
-      Map::const_iterator e = self->end();
-      for ( ; i != e; ++i ) {
-	rb_ary_push( ary, swig::from<std::pair<Map::key_type, 
-		     Map::mapped_type> >(*i) );
-      }
-      return ary;
-    }
-    
-    bool __contains__(const key_type& key) {
-      return self->find(key) != self->end();
-    }
-
-    %newobject key_iterator(VALUE *RUBY_SELF);
-    swig::ConstIterator* key_iterator(VALUE *RUBY_SELF) {
-      return swig::make_output_key_iterator($self->begin(), $self->begin(), 
-					    $self->end(), *RUBY_SELF);
-    }
-
-    %newobject value_iterator(VALUE *RUBY_SELF);
-    swig::ConstIterator* value_iterator(VALUE *RUBY_SELF) {
-      return swig::make_output_value_iterator($self->begin(), $self->begin(), 
-					      $self->end(), *RUBY_SELF);
-    }
-
-  }
-%enddef
-
-%define %swig_map_methods(Map...)
-  %swig_map_common(Map)
-  %extend {
-    VALUE __getitem__(const key_type& key) const {
-      Map::const_iterator i = self->find(key);
-      if ( i != self->end() )
-	return swig::from<Map::mapped_type>( i->second );
-      else
-	return Qnil;
-    }
-
-    void __setitem__(const key_type& key, const mapped_type& x) throw (std::out_of_range) {
-      (*self)[key] = x;
-    }
-
-  VALUE inspect()
-    {
-      Map::const_iterator i = $self->begin();
-      Map::const_iterator e = $self->end();
-      const char *type_name = swig::type_name< Map >();
-      VALUE str = rb_str_new2( type_name );
-      str = rb_str_cat2( str, " {" );
-      bool comma = false;
-      VALUE tmp;
-      for ( ; i != e; ++i, comma = true )
-	{
-	  if (comma) str = rb_str_cat2( str, "," );
-	  tmp = swig::from< Map::key_type >( i->first );
-	  tmp = rb_inspect( tmp );
-	  str = rb_str_buf_append( str, tmp );
-	  str = rb_str_cat2( str, "=>" );
-	  tmp = swig::from< Map::mapped_type >( i->second );
-	  tmp = rb_inspect( tmp );
-	  str = rb_str_buf_append( str, tmp );
-	}
-      str = rb_str_cat2( str, "}" );
-      return str;
-    }
-
-  VALUE to_a()
-    {
-      Map::const_iterator i = $self->begin();
-      Map::const_iterator e = $self->end();
-      VALUE ary = rb_ary_new2( std::distance( i, e ) );
-      VALUE tmp;
-      for ( ; i != e; ++i )
-	{
-	  // @todo: improve -- this should just be swig::from(*i)
-	  tmp = swig::from< std::pair<Map::key_type, 
-	    Map::mapped_type> >( *i );
-	  rb_ary_push( ary, tmp );
-	}
-      return ary;
-    }
-
-  VALUE to_s()
-    {
-      Map::iterator i = $self->begin();
-      Map::iterator e = $self->end();
-      VALUE str = rb_str_new2( "" );
-      VALUE tmp;
-      for ( ; i != e; ++i )
-	{
-	  // @todo: improve -- this should just be swig::from(*i)
-	  tmp = swig::from< std::pair<Map::key_type, 
-	    Map::mapped_type> >( *i );
-	  tmp = rb_obj_as_string( tmp );
-	  str = rb_str_buf_append( str, tmp );
-	}
-      return str;
-    }
-
-  }
-%enddef
-
-
-%mixin std::map "Enumerable";
-
-
-%rename("delete")     std::map::__delete__;
-%rename("reject!")    std::map::reject_bang;
-%rename("map!")       std::map::map_bang;
-%rename("empty?")     std::map::empty;
-%rename("include?" )  std::map::__contains__ const;
-%rename("has_key?" )  std::map::has_key const;
-
-%alias  std::map::push          "<<";
-
-
-%include <std/std_map.i>
diff --git a/share/swig/2.0.11/ruby/std_pair.i b/share/swig/2.0.11/ruby/std_pair.i
deleted file mode 100644
index 5b4c8ba..0000000
--- a/share/swig/2.0.11/ruby/std_pair.i
+++ /dev/null
@@ -1,206 +0,0 @@
-/*
-  Pairs
-*/
-%include <rubystdcommon.swg>
-
-//#define SWIG_STD_PAIR_ASVAL
-
-%fragment("StdPairTraits","header",fragment="StdTraits") {
-  namespace swig {
-
-    template <class T, class U >
-    struct traits_asval<std::pair<T,U> >  {
-      typedef std::pair<T,U> value_type;
-
-      static int get_pair(VALUE first, VALUE second,
-			  std::pair<T,U> *val)
-      {
-	if (val) {
-	  T *pfirst = &(val->first);
-	  int res1 = swig::asval((VALUE)first, pfirst);
-	  if (!SWIG_IsOK(res1)) return res1;
-	  U *psecond = &(val->second);
-	  int res2 = swig::asval((VALUE)second, psecond);
-	  if (!SWIG_IsOK(res2)) return res2;
-	  return res1 > res2 ? res1 : res2;
-	} else {
-	  T *pfirst = 0;
-	  int res1 = swig::asval((VALUE)first, pfirst);
-	  if (!SWIG_IsOK(res1)) return res1;
-	  U *psecond = 0;
-	  int res2 = swig::asval((VALUE)second, psecond);
-	  if (!SWIG_IsOK(res2)) return res2;
-	  return res1 > res2 ? res1 : res2;
-	}	
-      }
-
-      static int asval(VALUE obj, std::pair<T,U> *val) {
-	int res = SWIG_ERROR;
-	if ( TYPE(obj) == T_ARRAY ) {
-	  if (RARRAY_LEN(obj) == 2) {
-	    VALUE first = rb_ary_entry(obj,0);
-	    VALUE second = rb_ary_entry(obj,1);
-	    res = get_pair(first, second, val);
-	  }
-	} else {
-	  value_type *p;
-	  res = SWIG_ConvertPtr(obj,(void**)&p,
-				swig::type_info<value_type>(),0);
-	  if (SWIG_IsOK(res) && val)  *val = *p;
-	}
-	return res;
-      }
-    };
-
-    template <class T, class U >
-    struct traits_asptr<std::pair<T,U> >  {
-      typedef std::pair<T,U> value_type;
-
-      static int get_pair(VALUE first, VALUE second,
-			  std::pair<T,U> **val) 
-      {
-	if (val) {
-	  value_type *vp = %new_instance(std::pair<T,U>);
-	  T *pfirst = &(vp->first);
-	  int res1 = swig::asval((VALUE)first, pfirst);
-	  if (!SWIG_IsOK(res1)) return res1;
-	  U *psecond = &(vp->second);
-	  int res2 = swig::asval((VALUE)second, psecond);
-	  if (!SWIG_IsOK(res2)) return res2;
-	  *val = vp;
-	  return SWIG_AddNewMask(res1 > res2 ? res1 : res2);
-	} else {
-	  T *pfirst = 0;
-	  int res1 = swig::asval((VALUE)first, pfirst);
-	  if (!SWIG_IsOK(res1)) return res1;
-	  U *psecond = 0;
-	  int res2 = swig::asval((VALUE)second, psecond);
-	  if (!SWIG_IsOK(res2)) return res2;
-	  return res1 > res2 ? res1 : res2;
-	}	
-      }
-
-      static int asptr(VALUE obj, std::pair<T,U> **val) {
-	int res = SWIG_ERROR;
-	if ( TYPE(obj) == T_ARRAY ) {
-	  if ( RARRAY_LEN(obj) == 2) {
-	    VALUE first = rb_ary_entry(obj,0);
-	    VALUE second = rb_ary_entry(obj,1);
-	    res = get_pair(first, second, val);
-	  }
-	} else {
-	  value_type *p;
-	  res = SWIG_ConvertPtr(obj,(void**)&p,
-				swig::type_info<value_type>(),0);
-	  if (SWIG_IsOK(res) && val)  *val = p;
-	}
-	return res;
-      }
-    };
-
-
-
-    template <class T, class U >
-    struct traits_from<std::pair<T,U> >   {
-      static VALUE _wrap_pair_second( VALUE self )
-      {
-	std::pair< typename swig::noconst_traits<T >::noconst_type,U>* p = NULL;
-	swig::asptr( self, &p );
-	return swig::from( p->second );
-      }
-
-      static VALUE _wrap_pair_second_eq( VALUE self, VALUE arg )
-      {
-	std::pair< typename swig::noconst_traits<T >::noconst_type,U>* p = NULL;
-	swig::asptr( self, &p );
-	return swig::from( p->second );
-      }
-
-      static VALUE from(const std::pair<T,U>& val) {
-	VALUE obj = rb_ary_new2(2);
-	rb_ary_push(obj, swig::from<typename swig::noconst_traits<T >::noconst_type>(val.first));
-	rb_ary_push(obj, swig::from(val.second));
-	rb_define_singleton_method(obj, "second",
-				   VALUEFUNC(_wrap_pair_second), 0 );
-	rb_define_singleton_method(obj, "second=",
-				   VALUEFUNC(_wrap_pair_second_eq), 1 );
-	rb_obj_freeze(obj); // treat as immutable tuple
-	return obj;
-      }
-    };
-
-  }
-}
-
-// Missing typemap
-%typemap(in) std::pair* (int res) {
-  res = swig::asptr( $input, &$1 );
-  if (!SWIG_IsOK(res))
-    %argument_fail(res, "$1_type", $symname, $argnum); 
-}
-
-
-%define %swig_pair_methods(pair...)
-
-%extend { 
-  VALUE inspect() const
-    {
-      VALUE tmp;
-      const char *type_name = swig::type_name< pair >();
-      VALUE str = rb_str_new2( type_name );
-      str = rb_str_cat2( str, " (" );
-      tmp = swig::from( $self->first );
-      tmp = rb_obj_as_string( tmp );
-      str = rb_str_buf_append( str, tmp );
-      str = rb_str_cat2( str, "," );
-      tmp = swig::from( $self->second );
-      tmp = rb_obj_as_string( tmp );
-      str = rb_str_buf_append( str, tmp );
-      str = rb_str_cat2( str, ")" );
-      return str;
-    }
-
-  VALUE to_s() const
-    {
-      VALUE tmp;
-      VALUE str = rb_str_new2( "(" );
-      tmp = swig::from( $self->first );
-      tmp = rb_obj_as_string( tmp );
-      str = rb_str_buf_append( str, tmp );
-      str = rb_str_cat2( str, "," );
-      tmp = swig::from( $self->second );
-      tmp = rb_obj_as_string( tmp );
-      str = rb_str_buf_append( str, tmp );
-      str = rb_str_cat2( str, ")" );
-      return str;
-    }
-
-  VALUE __getitem__( int index )
-    { 
-      if (( index % 2 ) == 0 )
-	return swig::from( $self->first );
-      else
-	return swig::from( $self->second );
-    }
-
-  VALUE __setitem__( int index, VALUE obj )
-    { 
-      int res;
-      if (( index % 2 ) == 0 )
-	{
-	  res = swig::asval( obj, &($self->first) );
-	}
-      else
-	{
-	  res = swig::asval(obj, &($self->second) );
-	}
-      if (!SWIG_IsOK(res))
-	rb_raise( rb_eArgError, "invalid item for " #pair );
-      return obj;
-    }
-
-  } // extend
-
-%enddef
-
-%include <std/std_pair.i>
diff --git a/share/swig/2.0.11/shared_ptr.i b/share/swig/2.0.11/shared_ptr.i
deleted file mode 100644
index 450493d..0000000
--- a/share/swig/2.0.11/shared_ptr.i
+++ /dev/null
@@ -1,64 +0,0 @@
-// This is a helper file for shared_ptr and should not be included directly.
-
-// The main implementation detail in using this smart pointer of a type is to customise the code generated
-// to use a pointer to the smart pointer of the type, rather than the usual pointer to the underlying type.
-// So for some type T, shared_ptr<T> * is used rather than T *.
-
-// shared_ptr namespaces could be boost or std or std::tr1
-// For example for std::tr1, use:
-// #define SWIG_SHARED_PTR_NAMESPACE std
-// #define SWIG_SHARED_PTR_SUBNAMESPACE tr1
-
-#if !defined(SWIG_SHARED_PTR_NAMESPACE)
-# define SWIG_SHARED_PTR_NAMESPACE boost
-#endif
-
-#if defined(SWIG_SHARED_PTR_SUBNAMESPACE)
-# define SWIG_SHARED_PTR_QNAMESPACE SWIG_SHARED_PTR_NAMESPACE::SWIG_SHARED_PTR_SUBNAMESPACE
-#else
-# define SWIG_SHARED_PTR_QNAMESPACE SWIG_SHARED_PTR_NAMESPACE
-#endif
-
-namespace SWIG_SHARED_PTR_NAMESPACE {
-#if defined(SWIG_SHARED_PTR_SUBNAMESPACE)
-  namespace SWIG_SHARED_PTR_SUBNAMESPACE {
-#endif
-    template <class T> class shared_ptr {
-    };
-#if defined(SWIG_SHARED_PTR_SUBNAMESPACE)
-  }
-#endif
-}
-
-%fragment("SWIG_null_deleter", "header") {
-struct SWIG_null_deleter {
-  void operator() (void const *) const {
-  }
-};
-%#define SWIG_NO_NULL_DELETER_0 , SWIG_null_deleter()
-%#define SWIG_NO_NULL_DELETER_1
-%#define SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW
-%#define SWIG_NO_NULL_DELETER_SWIG_POINTER_OWN
-}
-
-
-// Workaround empty first macro argument bug
-#define SWIGEMPTYHACK
-// Main user macro for defining shared_ptr typemaps for both const and non-const pointer types
-%define %shared_ptr(TYPE...)
-%feature("smartptr", noblock=1) TYPE { SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > }
-SWIG_SHARED_PTR_TYPEMAPS(SWIGEMPTYHACK, TYPE)
-SWIG_SHARED_PTR_TYPEMAPS(const, TYPE)
-%enddef
-
-// Legacy macros
-%define SWIG_SHARED_PTR(PROXYCLASS, TYPE...)
-#warning "SWIG_SHARED_PTR(PROXYCLASS, TYPE) is deprecated. Please use %shared_ptr(TYPE) instead."
-%shared_ptr(TYPE)
-%enddef
-
-%define SWIG_SHARED_PTR_DERIVED(PROXYCLASS, BASECLASSTYPE, TYPE...)
-#warning "SWIG_SHARED_PTR_DERIVED(PROXYCLASS, BASECLASSTYPE, TYPE) is deprecated. Please use %shared_ptr(TYPE) instead."
-%shared_ptr(TYPE)
-%enddef
-
diff --git a/share/swig/2.0.11/std/_std_deque.i b/share/swig/2.0.11/std/_std_deque.i
deleted file mode 100644
index 7dd3552..0000000
--- a/share/swig/2.0.11/std/_std_deque.i
+++ /dev/null
@@ -1,139 +0,0 @@
-/* -----------------------------------------------------------------------------
- * _std_deque.i
- *
- * This file contains a generic definition of std::deque along with
- * some helper functions.  Specific language modules should include
- * this file to generate wrappers. 
- * ----------------------------------------------------------------------------- */
-
-%include <std_except.i>
-
-%{
-#include <deque>
-#include <stdexcept>
-%}
-
-
-/* This macro defines all of the standard methods for a deque.  This
-   is defined as a macro to simplify the task of specialization.  For
-   example,
-
-         template<> class deque<int> {
-         public:
-             %std_deque_methods(int);
-         };
-*/
-
-%define %std_deque_methods_noempty(T)
-       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;
-
-       deque();
-       deque(unsigned int size, const T& value=T());
-       deque(const deque<T> &);
-      ~deque();
-
-       void assign(unsigned int n, const T& value);
-       void swap(deque<T> &x);
-       unsigned int size() const;
-       unsigned int max_size() const;
-       void resize(unsigned int n, T c = T());
-       const_reference front();
-       const_reference back();
-       void push_front(const T& x);
-       void push_back(const T& x);
-       void pop_front();
-       void pop_back();
-       void clear();
-
-       /* Some useful extensions */
-       %extend {
-           const_reference getitem(int i) throw (std::out_of_range) {
-                int size = int(self->size());
-                if (i<0) i += size;
-                if (i>=0 && i<size)
-                    return (*self)[i];
-                else
-                    throw std::out_of_range("deque index out of range");
-           }
-           void setitem(int i, const T& x) throw (std::out_of_range) {
-                int size = int(self->size());
-                if (i<0) i+= size;
-                if (i>=0 && i<size)
-                    (*self)[i] = x;
-                else
-                    throw std::out_of_range("deque index out of range");
-           }
-           void delitem(int i) throw (std::out_of_range) {
-                int size = int(self->size());
-                if (i<0) i+= size;
-                if (i>=0 && i<size) {
-                    self->erase(self->begin()+i);
-                } else {
-                    throw std::out_of_range("deque index out of range");
-                }
-           }
-           std::deque<T> getslice(int i, int j) {
-                int size = int(self->size());
-                if (i<0) i = size+i;
-                if (j<0) j = size+j;
-                if (i<0) i = 0;
-                if (j>size) j = size;
-                std::deque<T > tmp(j-i);
-                std::copy(self->begin()+i,self->begin()+j,tmp.begin());
-                return tmp;
-            }
-            void setslice(int i, int j, const std::deque<T>& v) {
-                int size = int(self->size());
-                if (i<0) i = size+i;
-                if (j<0) j = size+j;
-                if (i<0) i = 0;
-                if (j>size) j = size;
-                if (int(v.size()) == j-i) {
-                    std::copy(v.begin(),v.end(),self->begin()+i);
-                } else {
-                    self->erase(self->begin()+i,self->begin()+j);
-                    if (i+1 <= size)
-                        self->insert(self->begin()+i+1,v.begin(),v.end());
-                    else
-                        self->insert(self->end(),v.begin(),v.end());
-                }
-            }
-            void delslice(int i, int j) {
-                int size = int(self->size());
-                if (i<0) i = size+i;
-                if (j<0) j = size+j;
-                if (i<0) i = 0;
-                if (j>size) j = size;
-                self->erase(self->begin()+i,self->begin()+j);
-            }
-       };
-%enddef
-
-#ifdef SWIGPHP
-%define %std_deque_methods(T)
-    %extend {
-        bool is_empty() const {
-            return self->empty();
-        }
-    };
-    %std_deque_methods_noempty(T)
-%enddef
-#else
-%define %std_deque_methods(T)
-    bool empty() const;
-    %std_deque_methods_noempty(T)
-%enddef
-#endif
-
-namespace std {
-    template<class T> class deque {
-    public:
-       %std_deque_methods(T);
-    };
-}
diff --git a/share/swig/2.0.11/std/std_basic_string.i b/share/swig/2.0.11/std/std_basic_string.i
deleted file mode 100644
index 7b0898a..0000000
--- a/share/swig/2.0.11/std/std_basic_string.i
+++ /dev/null
@@ -1,270 +0,0 @@
-%include <exception.i>
-%include <std_container.i>
-%include <std_alloc.i>
-%include <std_char_traits.i>
-
-
-%{
-#include <string>
-%}
-
-namespace std
-{
-  %naturalvar basic_string;
-}
-
-
-namespace std {
-
-  template <class _CharT, class _Traits = char_traits<_CharT>, typename _Alloc = allocator<_CharT> > 
-  class basic_string
-  {
-#if !defined(SWIG_STD_MODERN_STL) || defined(SWIG_STD_NOMODERN_STL)
-    %ignore push_back;
-    %ignore clear;
-    %ignore compare;
-    %ignore append;
-#endif
-
-  public:
-    typedef size_t size_type;    
-    typedef ptrdiff_t difference_type;
-    typedef _CharT value_type;
-    typedef value_type reference;
-    typedef value_type const_reference;
-    typedef _Alloc allocator_type;
-    
-    static const size_type npos;
-
-#ifdef SWIG_EXPORT_ITERATOR_METHODS
-  class iterator;
-  class reverse_iterator;
-  class const_iterator;
-  class const_reverse_iterator;
-#endif
-
-
-    %traits_swigtype(_CharT);
-    %fragment(SWIG_Traits_frag(_CharT));
-    
-
-    basic_string(const _CharT* __s, size_type __n);
-
-    // Capacity:
-
-    size_type length() const;
-
-    size_type max_size() const;
-
-    size_type capacity() const;
-
-    void reserve(size_type __res_arg = 0);
-
-
-    // Modifiers:
-
-    basic_string& 
-    append(const basic_string& __str);
-
-    basic_string& 
-    append(const basic_string& __str, size_type __pos, size_type __n);
-
-    basic_string& 
-    append(const _CharT* __s, size_type __n);
-    
-    basic_string& 
-    append(size_type __n, _CharT __c);
-
-    basic_string& 
-    assign(const basic_string& __str);
-
-    basic_string& 
-    assign(const basic_string& __str, size_type __pos, size_type __n);
-    
-    basic_string& 
-    assign(const _CharT* __s, size_type __n);
-
-    basic_string& 
-    insert(size_type __pos1, const basic_string& __str);    
-
-    basic_string& 
-    insert(size_type __pos1, const basic_string& __str,
-	   size_type __pos2, size_type __n);
-
-    basic_string& 
-    insert(size_type __pos, const _CharT* __s, size_type __n);
-
-    basic_string& 
-    insert(size_type __pos, size_type __n, _CharT __c);
-
-    basic_string& 
-    erase(size_type __pos = 0, size_type __n = npos);
-
-    basic_string& 
-    replace(size_type __pos, size_type __n, const basic_string& __str);
-
-    basic_string& 
-    replace(size_type __pos1, size_type __n1, const basic_string& __str,
-	    size_type __pos2, size_type __n2);
-
-    basic_string& 
-    replace(size_type __pos, size_type __n1, const _CharT* __s,
-	    size_type __n2);
-
-    basic_string& 
-    replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c);
-
-
-    size_type 
-    copy(_CharT* __s, size_type __n, size_type __pos = 0) const;    
-
-    // String operations:
-    const _CharT* c_str() const;
-
-    size_type 
-    find(const _CharT* __s, size_type __pos, size_type __n) const;
-    
-    size_type 
-    find(const basic_string& __str, size_type __pos = 0) const;
-
-    size_type 
-    find(_CharT __c, size_type __pos = 0) const;
-
-    size_type 
-    rfind(const basic_string& __str, size_type __pos = npos) const;
-
-    size_type 
-    rfind(const _CharT* __s, size_type __pos, size_type __n) const;
-
-    size_type 
-    rfind(_CharT __c, size_type __pos = npos) const;
-
-    size_type 
-    find_first_of(const basic_string& __str, size_type __pos = 0) const;
-
-    size_type 
-    find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
-
-    size_type 
-    find_first_of(_CharT __c, size_type __pos = 0) const;
-
-    size_type 
-    find_last_of(const basic_string& __str, size_type __pos = npos) const;
-    
-    size_type 
-    find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
-
-    size_type 
-    find_last_of(_CharT __c, size_type __pos = npos) const;
-    
-    size_type 
-    find_first_not_of(const basic_string& __str, size_type __pos = 0) const;
-
-    size_type 
-    find_first_not_of(const _CharT* __s, size_type __pos, 
-		      size_type __n) const;
-
-    size_type 
-    find_first_not_of(_CharT __c, size_type __pos = 0) const;
-
-    size_type 
-    find_last_not_of(const basic_string& __str, size_type __pos = npos) const;
-
-    size_type 
-    find_last_not_of(const _CharT* __s, size_type __pos, 
-		     size_type __n) const;
-    
-    size_type 
-    find_last_not_of(_CharT __c, size_type __pos = npos) const;
-
-    basic_string 
-    substr(size_type __pos = 0, size_type __n = npos) const;
-
-    int 
-    compare(const basic_string& __str) const;
-
-    int 
-    compare(size_type __pos, size_type __n, const basic_string& __str) const;
-
-    int 
-    compare(size_type __pos1, size_type __n1, const basic_string& __str,
-	    size_type __pos2, size_type __n2) const;
-
-
-    %ignore pop_back();
-    %ignore front() const;
-    %ignore back() const;
-    %ignore basic_string(size_type n);
-    %std_sequence_methods_val(basic_string);    
-
-
-    %ignore pop();
-
-
-#ifdef %swig_basic_string
-    // Add swig/language extra methods
-    %swig_basic_string(std::basic_string<_CharT, _Traits, _Alloc >);
-#endif
-
-#ifdef SWIG_EXPORT_ITERATOR_METHODS
-
-    
-    class iterator;
-    class reverse_iterator;
-    class const_iterator;
-    class const_reverse_iterator;
-
-
-    void 
-    insert(iterator __p, size_type __n, _CharT __c);
-
-    basic_string& 
-    replace(iterator __i1, iterator __i2, const basic_string& __str);
-
-    basic_string& 
-    replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n);
-
-    basic_string& 
-    replace(iterator __i1, iterator __i2, size_type __n, _CharT __c);
-
-
-    basic_string& 
-    replace(iterator __i1, iterator __i2, const _CharT* __k1, const _CharT* __k2);
-
-    basic_string& 
-    replace(iterator __i1, iterator __i2, const_iterator __k1, const_iterator __k2);
-#endif
-
-    basic_string& operator +=(const basic_string& v);
-
-    %newobject __add__;   
-    %newobject __radd__;
-    %extend {
-
-      std::basic_string<_CharT,_Traits,_Alloc >* __add__(const basic_string& v) {
-	std::basic_string<_CharT,_Traits,_Alloc >* res = new std::basic_string<_CharT,_Traits,_Alloc >(*self);
-	*res += v;      
-	return res;
-      }
-      
-      std::basic_string<_CharT,_Traits,_Alloc >* __radd__(const basic_string& v) {
-	std::basic_string<_CharT,_Traits,_Alloc >* res = new std::basic_string<_CharT,_Traits,_Alloc >(v);
-	*res += *self;      
-	return res;
-      }
-      
-      std::basic_string<_CharT,_Traits,_Alloc > __str__() {
-	return *self;
-      }
-
-      std::basic_ostream<_CharT, std::char_traits<_CharT> >&
-	__rlshift__(std::basic_ostream<_CharT, std::char_traits<_CharT> >& out) {
-	out << *self;
-	return out;
-      }
-    }
-
-  };
-}
-
-
diff --git a/share/swig/2.0.11/std/std_common.i b/share/swig/2.0.11/std/std_common.i
deleted file mode 100644
index 7c52880..0000000
--- a/share/swig/2.0.11/std/std_common.i
+++ /dev/null
@@ -1,239 +0,0 @@
-%include <std/std_except.i>
-
-//
-// Use the following macro with modern STL implementations
-//
-//#define SWIG_STD_MODERN_STL
-//
-// Use this to deactive the previous definition, when using gcc-2.95
-// or similar old compilers.
-//
-//#define SWIG_STD_NOMODERN_STL
-
-// Here, we identify compilers we know have problems with STL.
-%{
-#if defined(__GNUC__)
-#  if __GNUC__ == 2 && __GNUC_MINOR <= 96
-#     define SWIG_STD_NOMODERN_STL
-#  endif
-#endif
-%}
-
-//
-// Common code for supporting the C++ std namespace
-//
-
-%{
-#include <string>
-#include <stdexcept>
-#include <stddef.h>
-%}
-
-
-%fragment("StdIteratorTraits","header",fragment="<stddef.h>") %{
-#if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
-#  if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
-#    define SWIG_STD_NOITERATOR_TRAITS_STL
-#  endif
-#endif
-
-#if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
-#include <iterator>
-#else
-namespace std {
-  template <class Iterator>
-  struct iterator_traits {
-    typedef ptrdiff_t difference_type;
-    typedef typename Iterator::value_type value_type;
-  };
-
-  template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
-  struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
-    typedef Distance difference_type;
-    typedef T value_type;
-  };
-
-  template <class T>
-  struct iterator_traits<T*> {
-    typedef T value_type;
-    typedef ptrdiff_t difference_type;
-  };
-
-  template<typename _InputIterator>
-  inline typename iterator_traits<_InputIterator>::difference_type
-  distance(_InputIterator __first, _InputIterator __last)
-  {
-    typename iterator_traits<_InputIterator>::difference_type __n = 0;
-    while (__first != __last) {
-      ++__first; ++__n;
-    }
-    return __n;
-  }
-}
-#endif
-%}
-
-%fragment("StdTraitsCommon","header") %{
-namespace swig {  
-  template <class Type>
-  struct noconst_traits {
-    typedef Type noconst_type;
-  };
-
-  template <class Type>
-  struct noconst_traits<const Type> {
-    typedef Type noconst_type;
-  };
-
-  /*
-    type categories
-  */
-  struct pointer_category { };  
-  struct value_category { };
-
-  /*
-    General traits that provides type_name and type_info
-  */
-  template <class Type> struct traits { };
-
-  template <class Type>
-  inline const char* type_name() {
-    return traits<typename noconst_traits<Type >::noconst_type >::type_name();
-  }
-
-  template <class Type> 
-  struct traits_info {
-    static swig_type_info *type_query(std::string name) {
-      name += " *";
-      return SWIG_TypeQuery(name.c_str());
-    }    
-    static swig_type_info *type_info() {
-      static swig_type_info *info = type_query(type_name<Type>());
-      return info;
-    }
-  };
-
-  template <class Type>
-  inline swig_type_info *type_info() {
-    return traits_info<Type>::type_info();
-  }
-
-  /*
-    Partial specialization for pointers
-  */
-  template <class Type> struct traits <Type *> {
-    typedef pointer_category category;
-    static std::string make_ptr_name(const char* name) {
-      std::string ptrname = name;
-      ptrname += " *";
-      return ptrname;
-    }    
-    static const char* type_name() {
-      static std::string name = make_ptr_name(swig::type_name<Type>());
-      return name.c_str();
-    }
-  };
-
-  template <class Type, class Category> 
-  struct traits_as { };
- 
-  template <class Type, class Category> 
-  struct traits_check { };
-
-}
-%}
- 
-/*
-  Generate the traits for a swigtype
-*/
-
-%define %traits_swigtype(Type...)
-%fragment(SWIG_Traits_frag(Type),"header",fragment="StdTraits") {
-  namespace swig {
-    template <>  struct traits<Type > {
-      typedef pointer_category category;
-      static const char* type_name() { return  #Type; }
-    };
-  }
-}
-%enddef
-
-
-
-/*
-  Generate the typemaps for a class that has 'value' traits
-*/
-
-%define %typemap_traits(Code,Type...)
-  %typemaps_asvalfrom(%arg(Code),
-		     %arg(swig::asval<Type >),
-		     %arg(swig::from),
-		     %arg(SWIG_Traits_frag(Type)),
-		     %arg(SWIG_Traits_frag(Type)),
-		     Type);
-%enddef
-
-/*
-  Generate the typemaps for a class that behaves more like a 'pointer' or
-  plain wrapped Swigtype.
-*/
-
-%define %typemap_traits_ptr(Code,Type...)
-  %typemaps_asptrfrom(%arg(Code),
-		     %arg(swig::asptr),
-		     %arg(swig::from),
-		     %arg(SWIG_Traits_frag(Type)),
-		     %arg(SWIG_Traits_frag(Type)),
-		     Type);
-%enddef
-
-
-/*
-  Equality methods
-*/
-%define %std_equal_methods(Type...)
-%extend Type {
-  bool operator == (const Type& v) {
-    return *self == v;
-  }
-  
-  bool operator != (const Type& v) {
-    return *self != v;
-  }  
-}
-
-%enddef
-
-/*
-  Order methods
-*/
-
-%define %std_order_methods(Type...)
-%extend Type {
-  bool operator > (const Type& v) {
-    return *self > v;
-  }
-  
-  bool operator < (const Type& v) {
-    return *self < v;
-  }
-
-  bool operator >= (const Type& v) {
-    return *self >= v;
-  }
-
-  bool operator <= (const Type& v) {
-    return *self <= v;
-  }
-}
-%enddef
-
-/*
-  Comparison methods
-*/
-
-%define %std_comp_methods(Type...)
-%std_equal_methods(Type )
-%std_order_methods(Type )
-%enddef
-
diff --git a/share/swig/2.0.11/std/std_container.i b/share/swig/2.0.11/std/std_container.i
deleted file mode 100644
index 73d0c6a..0000000
--- a/share/swig/2.0.11/std/std_container.i
+++ /dev/null
@@ -1,109 +0,0 @@
-%include <std_common.i>
-%include <exception.i>
-%include <std_alloc.i>
-
-%{
-#include <algorithm>
-%}
-
-// Common container methods
-
-%define %std_container_methods(container...)
-  container();
-  container(const container&);
-
-  bool empty() const;
-  size_type size() const;
-  void clear();
-
-  void swap(container& v);
-
-  allocator_type get_allocator() const;
-
-  #ifdef SWIG_EXPORT_ITERATOR_METHODS
-  class iterator;
-  class reverse_iterator;
-  class const_iterator;
-  class const_reverse_iterator;
-
-  iterator begin();
-  iterator end();
-  reverse_iterator rbegin();
-  reverse_iterator rend();
-  #endif
-
-%enddef
-
-// Common sequence
-
-%define %std_sequence_methods_common(sequence)
-  
-  %std_container_methods(%arg(sequence));
-  
-  sequence(size_type size);
-  void pop_back();
-  
-  void resize(size_type new_size);
-  
-  #ifdef SWIG_EXPORT_ITERATOR_METHODS
-  iterator erase(iterator pos);
-  iterator erase(iterator first, iterator last);
-  #endif
-  
-%enddef
-
-
-%define %std_sequence_methods(sequence)
-  
-  %std_sequence_methods_common(%arg(sequence));
-  
-  sequence(size_type size, const value_type& value);
-  void push_back(const value_type& x);  
-
-  const value_type& front() const;
-  const value_type& back() const;
- 
-  void assign(size_type n, const value_type& x);
-
-  void resize(size_type new_size, const value_type& x);
-  
-  #ifdef SWIG_EXPORT_ITERATOR_METHODS
-  iterator insert(iterator pos, const value_type& x);
-  void insert(iterator pos, size_type n, const value_type& x);
-  #endif
-  
-%enddef
-
-%define %std_sequence_methods_val(sequence...)
-  
-  %std_sequence_methods_common(%arg(sequence));
-  
-  sequence(size_type size, value_type value);
-  void push_back(value_type x);  
-
-  value_type front() const;
-  value_type back() const;
- 
-  void assign(size_type n, value_type x);
-
-  void resize(size_type new_size, value_type x);
-  
-  #ifdef SWIG_EXPORT_ITERATOR_METHODS
-  iterator insert(iterator pos, value_type x);
-  void insert(iterator pos, size_type n, value_type x);
-  #endif
-  
-%enddef
-
-
-//
-// Ignore member methods for Type with no default constructor
-//
-%define %std_nodefconst_type(Type...)
-%feature("ignore") std::vector<Type >::vector(size_type size);
-%feature("ignore") std::vector<Type >::resize(size_type size);
-%feature("ignore") std::deque<Type >::deque(size_type size);
-%feature("ignore") std::deque<Type >::resize(size_type size);
-%feature("ignore") std::list<Type >::list(size_type size);
-%feature("ignore") std::list<Type >::resize(size_type size);
-%enddef
diff --git a/share/swig/2.0.11/std/std_deque.i b/share/swig/2.0.11/std/std_deque.i
deleted file mode 100644
index a99763b..0000000
--- a/share/swig/2.0.11/std/std_deque.i
+++ /dev/null
@@ -1,127 +0,0 @@
-//
-// std::deque
-
-%include <std_container.i>
-
-// Deque
-
-%define %std_deque_methods(deque...)  
-  %std_sequence_methods(deque)
-
-  void pop_front();
-  void push_front(const value_type& x);
-%enddef
-
-%define %std_deque_methods_val(deque...)
-  %std_sequence_methods_val(deque)
-
-  void pop_front();
-  void push_front(value_type x);
-%enddef
-
-// ------------------------------------------------------------------------
-// std::deque
-// 
-// const declarations are used to guess the intent of the function being
-// exported; therefore, the following rationale is applied:
-// 
-//   -- f(std::deque<T>), f(const std::deque<T>&):
-//      the parameter being read-only, either a sequence or a
-//      previously wrapped std::deque<T> can be passed.
-//   -- f(std::deque<T>&), f(std::deque<T>*):
-//      the parameter may be modified; therefore, only a wrapped std::deque
-//      can be passed.
-//   -- std::deque<T> f(), const std::deque<T>& f():
-//      the deque is returned by copy; therefore, a sequence of T:s 
-//      is returned which is most easily used in other functions
-//   -- std::deque<T>& f(), std::deque<T>* f():
-//      the deque is returned by reference; therefore, a wrapped std::deque
-//      is returned
-//   -- const std::deque<T>* f(), f(const std::deque<T>*):
-//      for consistency, they expect and return a plain deque pointer.
-// ------------------------------------------------------------------------
-
-%{
-#include <deque>
-%}
-
-// exported classes
-
-namespace std {
-
-  template<class _Tp, class _Alloc = allocator<_Tp> > 
-  class deque {
-  public:
-    typedef size_t size_type;
-    typedef ptrdiff_t difference_type;
-    typedef _Tp 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;
-
-    %traits_swigtype(_Tp);
-
-    %fragment(SWIG_Traits_frag(std::deque<_Tp, _Alloc >), "header",
-	      fragment=SWIG_Traits_frag(_Tp),
-	      fragment="StdDequeTraits") {
-      namespace swig {
-	template <>  struct traits<std::deque<_Tp, _Alloc > > {
-	  typedef pointer_category category;
-	  static const char* type_name() {
-	    return "std::deque<" #_Tp " >";
-	  }
-	};
-      }
-    }
-
-    %typemap_traits_ptr(SWIG_TYPECHECK_DEQUE, std::deque<_Tp, _Alloc >);
-  
-#ifdef %swig_deque_methods
-    // Add swig/language extra methods
-    %swig_deque_methods(std::deque<_Tp, _Alloc >);
-#endif
-
-    %std_deque_methods(deque);
-  };
-
-  template<class _Tp, class _Alloc > 
-  class deque<_Tp*, _Alloc > {
-  public:
-    typedef size_t size_type;
-    typedef ptrdiff_t difference_type;
-    typedef _Tp* value_type;
-    typedef value_type* pointer;
-    typedef const value_type* const_pointer;
-    typedef value_type reference;
-    typedef value_type const_reference;
-    typedef _Alloc allocator_type;
-
-    %traits_swigtype(_Tp);
-
-    %fragment(SWIG_Traits_frag(std::deque<_Tp*, _Alloc >), "header",
-	      fragment=SWIG_Traits_frag(_Tp),
-	      fragment="StdDequeTraits") {
-      namespace swig {
-	template <>  struct traits<std::deque<_Tp*, _Alloc > > {
-	  typedef value_category category;
-	  static const char* type_name() {
-	    return "std::deque<" #_Tp " * >";
-	  }
-	};
-      }
-    }
-
-    %typemap_traits_ptr(SWIG_TYPECHECK_DEQUE, std::deque<_Tp*, _Alloc >);
-
-#ifdef %swig_deque_methods_val
-    // Add swig/language extra methods
-    %swig_deque_methods_val(std::deque<_Tp*, _Alloc >);
-#endif
-
-    %std_deque_methods_val(std::deque<_Tp*, _Alloc >);
-  };
-
-}
-
diff --git a/share/swig/2.0.11/std/std_except.i b/share/swig/2.0.11/std/std_except.i
deleted file mode 100644
index 75b8d0f..0000000
--- a/share/swig/2.0.11/std/std_except.i
+++ /dev/null
@@ -1,68 +0,0 @@
-#if defined(SWIGJAVA) || defined(SWIGCSHARP)
-#error "do not use this version of std_except.i"
-#endif
-
-%{
-#include <stdexcept>
-%}
-
-#if defined(SWIG_STD_EXCEPTIONS_AS_CLASSES)
-
-namespace std {
-  struct exception 
-  {
-    virtual ~exception() throw();
-    virtual const char* what() const throw();
-  };
-
-  struct bad_exception : exception 
-  {
-  };
-
-  struct logic_error : exception 
-  {
-    logic_error(const string& msg);
-  };
-
-  struct domain_error : logic_error 
-  {
-    domain_error(const string& msg);
-  };
-
-  struct invalid_argument : logic_error 
-  {
-    invalid_argument(const string& msg);
-  };
-
-  struct length_error : logic_error 
-  {
-    length_error(const string& msg);
-  };
-
-  struct out_of_range : logic_error 
-  {
-    out_of_range(const string& msg);
-  };
-
-  struct runtime_error : exception 
-  {
-    runtime_error(const string& msg);
-  };
-
-  struct range_error : runtime_error 
-  {
-    range_error(const string& msg);
-  };
-
-  struct overflow_error : runtime_error 
-  {
-    overflow_error(const string& msg);
-  };
-
-  struct underflow_error : runtime_error 
-  {
-    underflow_error(const string& msg);
-  };
-}
-
-#endif
diff --git a/share/swig/2.0.11/std/std_ios.i b/share/swig/2.0.11/std/std_ios.i
deleted file mode 100644
index 75484f3..0000000
--- a/share/swig/2.0.11/std/std_ios.i
+++ /dev/null
@@ -1,260 +0,0 @@
-%include <std_char_traits.i>
-%include <std_basic_string.i>
-%include <std_except.i>
-%{
-#ifndef SWIG_STD_NOMODERN_STL
-# include <ios>
-#else
-# include <streambuf.h>
-#endif
-%}
-
-namespace std {
-
-  template<typename _CharT, typename _Traits = char_traits<_CharT> >
-  class basic_streambuf;
-
-  template<typename _CharT, typename _Traits = char_traits<_CharT> >
-  class basic_istream;
-
-  template<typename _CharT, typename _Traits = char_traits<_CharT> >
-  class basic_ostream;
-
-  // 27.4.2  Class ios_base
-  typedef size_t streamsize;
-
-  class locale;
-  
-  
-  class ios_base
-  {
-  public:
-    
-#ifdef SWIG_NESTED_CLASSES
-    // 27.4.2.1.1  Class ios_base::failure
-    class failure : public exception
-    {
-    public:
-      explicit failure(const string& __str) throw();
-    };
-#endif
-
-    // 27.4.2.1.2  Type ios_base::fmtflags
-    typedef int fmtflags;
-    // 27.4.2.1.2  Type fmtflags
-    static const fmtflags boolalpha ;
-    static const fmtflags dec ;
-    static const fmtflags fixed ;
-    static const fmtflags hex ;
-    static const fmtflags internal ;
-    static const fmtflags left ;
-    static const fmtflags oct ;
-    static const fmtflags right ;
-    static const fmtflags scientific ;
-    static const fmtflags showbase ;
-    static const fmtflags showpoint ;
-    static const fmtflags showpos ;
-    static const fmtflags skipws ;
-    static const fmtflags unitbuf ;
-    static const fmtflags uppercase ;
-    static const fmtflags adjustfield ;
-    static const fmtflags basefield ;
-    static const fmtflags floatfield ;
-
-    // 27.4.2.1.3  Type ios_base::iostate
-    typedef int iostate;
-    static const iostate badbit ;
-    static const iostate eofbit ;
-    static const iostate failbit ;
-    static const iostate goodbit ;
-
-    // 27.4.2.1.4  Type openmode
-    typedef int openmode;
-    static const openmode app ;
-    static const openmode ate ;
-    static const openmode binary ;
-    static const openmode in ;
-    static const openmode out ;
-    static const openmode trunc ;
-
-    // 27.4.2.1.5  Type seekdir
-    typedef int seekdir;
-    static const seekdir beg ;
-    static const seekdir cur ;
-    static const seekdir end ;
-
-
-    // Callbacks;
-    enum event
-      {
-	erase_event,
-	imbue_event,
-	copyfmt_event
-      };
-
-    typedef void (*event_callback) (event, ios_base&, int);
-
-    void 
-    register_callback(event_callback __fn, int __index);
-
-    // Fmtflags state:
-    inline fmtflags 
-    flags() const ;
-
-    inline fmtflags 
-    flags(fmtflags __fmtfl);
-
-    inline fmtflags 
-    setf(fmtflags __fmtfl);
-
-    inline fmtflags 
-    setf(fmtflags __fmtfl, fmtflags __mask);
-
-    inline void 
-    unsetf(fmtflags __mask) ;
-
-    inline streamsize 
-    precision() const ;
-
-    inline streamsize 
-    precision(streamsize __prec);
-
-    inline streamsize 
-    width() const ;
-
-    inline streamsize 
-    width(streamsize __wide);
-
-    static bool 
-    sync_with_stdio(bool __sync = true);
-
-    // Locales:
-    locale 
-    imbue(const locale& __loc);
-
-    inline locale 
-    getloc() const { return _M_ios_locale; }
-
-    // Storage:
-    static int 
-    xalloc() throw();
-
-    inline long& 
-    iword(int __ix);
-
-    inline void*& 
-    pword(int __ix);
-
-    // Destructor
-    ~ios_base();
-
-  protected:
-    ios_base();
-
-  //50.  Copy constructor and assignment operator of ios_base
-  private:
-    ios_base(const ios_base&);
-
-    ios_base& 
-    operator=(const ios_base&);
-  };
-
-  template<typename _CharT, typename _Traits = char_traits<_CharT> >
-  class basic_ios : public ios_base
-  {
-  public:
-    // Types:
-    typedef _CharT 				char_type;
-    typedef typename _Traits::int_type 	int_type;
-    typedef typename _Traits::pos_type 	pos_type;
-    typedef typename _Traits::off_type 	off_type;
-    typedef _Traits 				traits_type;
-      
-  public:
-
-    iostate 
-    rdstate() const;
-
-    void 
-    clear(iostate __state = goodbit);
-
-    void 
-    setstate(iostate __state);
-
-    bool 
-    good() const;
-
-    bool 
-    eof() const;
-
-    bool 
-    fail() const;
-
-    bool 
-    bad() const;
-
-    iostate 
-    exceptions() const;
-
-    void 
-    exceptions(iostate __except);
-
-    // Constructor/destructor:
-    explicit 
-    basic_ios(basic_streambuf<_CharT, _Traits>* __sb) : ios_base();
-
-    virtual 
-    ~basic_ios() ;
-      
-    // Members:
-    basic_ostream<_CharT, _Traits>*
-    tie() const;
-
-    basic_ostream<_CharT, _Traits>*
-    tie(basic_ostream<_CharT, _Traits>* __tiestr);
-
-    basic_streambuf<_CharT, _Traits>*
-    rdbuf() const;
-
-    basic_streambuf<_CharT, _Traits>* 
-    rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
-
-    basic_ios&
-    copyfmt(const basic_ios& __rhs);
-
-    char_type 
-    fill() const;
-
-    char_type 
-    fill(char_type __ch);
-
-    // Locales:
-    locale 
-    imbue(const locale& __loc);
-
-    char 
-    narrow(char_type __c, char __dfault) const;
-
-    char_type 
-    widen(char __c) const;
-     
-  protected:
-    // 27.4.5.1  basic_ios constructors
-    basic_ios();
-  private:
-    ios_base(const ios_base&);
-
-    ios_base& 
-    operator=(const ios_base&);
-  };
-  
-}
-
-namespace std {
-  %template(ios) basic_ios<char>;
-#if defined(SWIG_WCHAR)
-  %template(wios) basic_ios<wchar_t>;
-#endif
-}
-
-  
diff --git a/share/swig/2.0.11/std/std_list.i b/share/swig/2.0.11/std/std_list.i
deleted file mode 100644
index e089351..0000000
--- a/share/swig/2.0.11/std/std_list.i
+++ /dev/null
@@ -1,148 +0,0 @@
-//
-// std::list
-//
-
-%include <std_container.i>
-
-// List
-
-%define %std_list_methods(list)
-  %std_sequence_methods(list)
-  
-  void pop_front();
-  void push_front(const value_type& x);
-  		
-  void reverse();
-  
-%enddef
-
-
-%define %std_list_methods_val(list)
-  %std_sequence_methods_val(list)
-  
-  void pop_front();
-  void push_front(value_type x);
-  		
-  void remove(value_type x);
-  void unique();
-  void reverse();
-  void sort();
-  
-  void merge(list& x);
-%enddef
-
-// ------------------------------------------------------------------------
-// std::list
-// 
-// const declarations are used to guess the intent of the function being
-// exported; therefore, the following rationale is applied:
-// 
-//   -- f(std::list<T>), f(const std::list<T>&):
-//      the parameter being read-only, either a sequence or a
-//      previously wrapped std::list<T> can be passed.
-//   -- f(std::list<T>&), f(std::list<T>*):
-//      the parameter may be modified; therefore, only a wrapped std::list
-//      can be passed.
-//   -- std::list<T> f(), const std::list<T>& f():
-//      the list is returned by copy; therefore, a sequence of T:s 
-//      is returned which is most easily used in other functions
-//   -- std::list<T>& f(), std::list<T>* f():
-//      the list is returned by reference; therefore, a wrapped std::list
-//      is returned
-//   -- const std::list<T>* f(), f(const std::list<T>*):
-//      for consistency, they expect and return a plain list pointer.
-// ------------------------------------------------------------------------
-
-%{
-#include <list>
-%}
-
-// exported classes
-
-namespace std {
-
-  template<class _Tp, class _Alloc = allocator<_Tp>  > 
-  class list {
-  public:
-    typedef size_t size_type;
-    typedef ptrdiff_t difference_type;
-    typedef _Tp 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;
-
-    %traits_swigtype(_Tp);
-
-    %fragment(SWIG_Traits_frag(std::list<_Tp, _Alloc >), "header",
-	      fragment=SWIG_Traits_frag(_Tp),
-	      fragment="StdListTraits") {
-      namespace swig {
-	template <>  struct traits<std::list<_Tp, _Alloc > > {
-	  typedef pointer_category category;
-	  static const char* type_name() {
-	    return "std::list<" #_Tp ", " #_Alloc " >";
-	  }
-	};
-      }
-    }
-
-    %typemap_traits_ptr(SWIG_TYPECHECK_LIST, std::list<_Tp, _Alloc >);
-
-#ifdef %swig_list_methods
-    // Add swig/language extra methods
-    %swig_list_methods(std::list<_Tp, _Alloc >);
-#endif
-  
-    %std_list_methods(list);
-  };
-
-  template<class _Tp, class _Alloc >
-  class list<_Tp*, _Alloc> {
-  public:
-    typedef size_t size_type;
-    typedef ptrdiff_t difference_type;
-    typedef _Tp* value_type;
-    typedef value_type* pointer;
-    typedef const value_type* const_pointer;
-    typedef value_type reference;
-    typedef value_type const_reference;
-    typedef _Alloc allocator_type;
-
-    %traits_swigtype(_Tp);
-
-    %fragment(SWIG_Traits_frag(std::list<_Tp*, _Alloc >), "header",
-	      fragment=SWIG_Traits_frag(_Tp),
-	      fragment="StdListTraits") {
-      namespace swig {
-	template <>  struct traits<std::list<_Tp*, _Alloc > > {
-	  typedef value_category category;
-	  static const char* type_name() {
-	    return "std::list<" #_Tp " *," #_Alloc " >";
-	  }
-	};
-      }
-    }
-
-    %typemap_traits_ptr(SWIG_TYPECHECK_LIST, std::list<_Tp*, _Alloc >);
-
-#ifdef %swig_list_methods_val
-    // Add swig/language extra methods
-    %swig_list_methods_val(std::list<_Tp*, _Alloc >);
-#endif
-
-    %std_list_methods_val(list);
-  };
-
-}
-
-%define %std_extequal_list(...)
-%extend std::list<__VA_ARGS__ > { 
-  void remove(const value_type& x) { self->remove(x); }  
-  void merge(std::list<__VA_ARGS__ >& x){ self->merge(x); }  
-  void unique() { self->unique(); }  
-  void sort() { self->sort(); }  
-}
-%enddef
-
diff --git a/share/swig/2.0.11/std/std_map.i b/share/swig/2.0.11/std/std_map.i
deleted file mode 100644
index 0520841..0000000
--- a/share/swig/2.0.11/std/std_map.i
+++ /dev/null
@@ -1,124 +0,0 @@
-//
-// std::map
-//
-
-%include <std_pair.i>
-%include <std_container.i>
-
-%define %std_map_methods_common(map...)
-  %std_container_methods(map);
-
-  size_type erase(const key_type& x);
-  size_type count(const key_type& x) const;
-
-#ifdef SWIG_EXPORT_ITERATOR_METHODS
-//  iterator insert(iterator position, const value_type& x);
-  void erase(iterator position);
-  void erase(iterator first, iterator last);
-
-  iterator find(const key_type& x);
-  iterator lower_bound(const key_type& x);
-  iterator upper_bound(const key_type& x);
-#endif
-%enddef
-
-%define %std_map_methods(map...)
-  %std_map_methods_common(map);
-
-  #ifdef SWIG_EXPORT_ITERATOR_METHODS
-//  iterator insert(const value_type& x);
-  #endif
-%enddef
-
-
-// ------------------------------------------------------------------------
-// std::map
-// 
-// const declarations are used to guess the intent of the function being
-// exported; therefore, the following rationale is applied:
-// 
-//   -- f(std::map<T>), f(const std::map<T>&):
-//      the parameter being read-only, either a sequence or a
-//      previously wrapped std::map<T> can be passed.
-//   -- f(std::map<T>&), f(std::map<T>*):
-//      the parameter may be modified; therefore, only a wrapped std::map
-//      can be passed.
-//   -- std::map<T> f(), const std::map<T>& f():
-//      the map is returned by copy; therefore, a sequence of T:s 
-//      is returned which is most easily used in other functions
-//   -- std::map<T>& f(), std::map<T>* f():
-//      the map is returned by reference; therefore, a wrapped std::map
-//      is returned
-//   -- const std::map<T>* f(), f(const std::map<T>*):
-//      for consistency, they expect and return a plain map pointer.
-// ------------------------------------------------------------------------
-
-%{
-#include <map>
-#include <algorithm>
-#include <stdexcept>
-%}
-
-// exported class
-
-namespace std {
-
-  template<class _Key, class _Tp, class _Compare = std::less<_Key >,
-	   class _Alloc = allocator<std::pair<const _Key, _Tp > > >
-  class map {
-  public:
-    typedef size_t size_type;
-    typedef ptrdiff_t difference_type;
-    typedef _Key key_type;
-    typedef _Tp mapped_type;
-    typedef std::pair<const _Key, _Tp> 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;
-
-    %traits_swigtype(_Key);
-    %traits_swigtype(_Tp);	    
-
-    %fragment(SWIG_Traits_frag(std::pair< _Key, _Tp >), "header",
-	      fragment=SWIG_Traits_frag(_Key),
-	      fragment=SWIG_Traits_frag(_Tp),
-	      fragment="StdPairTraits") {
-      namespace swig {
-	template <>  struct traits<std::pair< _Key, _Tp > > {
-	  typedef pointer_category category;
-	  static const char* type_name() {
-	    return "std::pair<" #_Key "," #_Tp " >";
-	  }
-	};
-      }
-    }
-
-    %fragment(SWIG_Traits_frag(std::map<_Key, _Tp, _Compare, _Alloc >), "header",
-	      fragment=SWIG_Traits_frag(std::pair<_Key, _Tp >),
-	      fragment="StdMapTraits") {
-      namespace swig {
-	template <>  struct traits<std::map<_Key, _Tp, _Compare, _Alloc > > {
-	  typedef pointer_category category;
-	  static const char* type_name() {
-	    return "std::map<" #_Key "," #_Tp "," #_Compare "," #_Alloc " >";
-	  }
-	};
-      }
-    }
-
-    %typemap_traits_ptr(SWIG_TYPECHECK_MAP, std::map<_Key, _Tp, _Compare, _Alloc >);
-
-    map( const _Compare& );
-
-#ifdef %swig_map_methods
-    // Add swig/language extra methods
-    %swig_map_methods(std::map<_Key, _Tp, _Compare, _Alloc >);
-#endif
-  
-    %std_map_methods(map);
-  };
-
-}
diff --git a/share/swig/2.0.11/std/std_multimap.i b/share/swig/2.0.11/std/std_multimap.i
deleted file mode 100644
index 5a2cf38..0000000
--- a/share/swig/2.0.11/std/std_multimap.i
+++ /dev/null
@@ -1,101 +0,0 @@
-//
-// std::map
-//
-
-%include <std_map.i>
-
-
-%define %std_multimap_methods(mmap...)
-  %std_map_methods_common(mmap);
-
-#ifdef SWIG_EXPORT_ITERATOR_METHODS
-  std::pair<iterator,iterator> equal_range(const key_type& x);
-  std::pair<const_iterator,const_iterator> equal_range(const key_type& x) const;
-#endif
-%enddef
-
-// ------------------------------------------------------------------------
-// std::multimap
-// 
-// const declarations are used to guess the intent of the function being
-// exported; therefore, the following rationale is applied:
-// 
-//   -- f(std::multimap<T>), f(const std::multimap<T>&):
-//      the parameter being read-only, either a sequence or a
-//      previously wrapped std::multimap<T> can be passed.
-//   -- f(std::multimap<T>&), f(std::multimap<T>*):
-//      the parameter may be modified; therefore, only a wrapped std::multimap
-//      can be passed.
-//   -- std::multimap<T> f(), const std::multimap<T>& f():
-//      the map is returned by copy; therefore, a sequence of T:s 
-//      is returned which is most easily used in other functions
-//   -- std::multimap<T>& f(), std::multimap<T>* f():
-//      the map is returned by reference; therefore, a wrapped std::multimap
-//      is returned
-//   -- const std::multimap<T>* f(), f(const std::multimap<T>*):
-//      for consistency, they expect and return a plain map pointer.
-// ------------------------------------------------------------------------
-
-
-// exported class
-
-
-namespace std {
-  template<class _Key, class _Tp, class _Compare = std::less<_Key >,
-	   class _Alloc = allocator<std::pair<const _Key, _Tp > > >
-  class multimap {
-  public:
-    typedef size_t size_type;
-    typedef ptrdiff_t difference_type;
-    typedef _Key key_type;
-    typedef _Tp mapped_type;
-    typedef std::pair<const _Key, _Tp> 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;
-
-    %traits_swigtype(_Key);
-    %traits_swigtype(_Tp);	    
-
-    %fragment(SWIG_Traits_frag(std::pair< _Key, _Tp >), "header",
-	      fragment=SWIG_Traits_frag(_Key),
-	      fragment=SWIG_Traits_frag(_Tp),
-	      fragment="StdPairTraits") {
-      namespace swig {
-	template <>  struct traits<std::pair< _Key, _Tp > > {
-	  typedef pointer_category category;
-	  static const char* type_name() {
-	    return "std::pair<" #_Key "," #_Tp " >";
-	  }
-	};
-      }
-    }
-
-    %fragment(SWIG_Traits_frag(std::multimap<_Key, _Tp, _Compare, _Alloc >), "header",
-	      fragment=SWIG_Traits_frag(std::pair<_Key, _Tp >),
-	      fragment="StdMultimapTraits") {
-      namespace swig {
-	template <>  struct traits<std::multimap<_Key, _Tp, _Compare, _Alloc > > {
-	  typedef pointer_category category;
-	  static const char* type_name() {
-	    return "std::multimap<" #_Key "," #_Tp "," #_Compare "," #_Alloc " >";
-	  }
-	};
-      }
-    }
-
-    %typemap_traits_ptr(SWIG_TYPECHECK_MULTIMAP, std::multimap<_Key, _Tp, _Compare, _Alloc >);
-  
-    multimap( const _Compare& );
-
-#ifdef %swig_multimap_methods
-    // Add swig/language extra methods
-    %swig_multimap_methods(std::multimap<_Key, _Tp, _Compare, _Alloc >);
-#endif
-
-    %std_multimap_methods(multimap);
-  };
-}
diff --git a/share/swig/2.0.11/std/std_multiset.i b/share/swig/2.0.11/std/std_multiset.i
deleted file mode 100644
index 98a7fb9..0000000
--- a/share/swig/2.0.11/std/std_multiset.i
+++ /dev/null
@@ -1,83 +0,0 @@
-//
-// std::set
-//
-
-%include <std_set.i>
-
-// Multiset
-
-%define %std_multiset_methods(multiset...)
-  %std_set_methods_common(multiset);
-%enddef
-
-
-// ------------------------------------------------------------------------
-// std::multiset
-// 
-// const declarations are used to guess the intent of the function being
-// exported; therefore, the following rationale is applied:
-// 
-//   -- f(std::multiset<T>), f(const std::multiset<T>&):
-//      the parameter being read-only, either a sequence or a
-//      previously wrapped std::multiset<T> can be passed.
-//   -- f(std::multiset<T>&), f(std::multiset<T>*):
-//      the parameter may be modified; therefore, only a wrapped std::multiset
-//      can be passed.
-//   -- std::multiset<T> f(), const std::multiset<T>& f():
-//      the set is returned by copy; therefore, a sequence of T:s 
-//      is returned which is most easily used in other functions
-//   -- std::multiset<T>& f(), std::multiset<T>* f():
-//      the set is returned by reference; therefore, a wrapped std::multiset
-//      is returned
-//   -- const std::multiset<T>* f(), f(const std::multiset<T>*):
-//      for consistency, they expect and return a plain set pointer.
-// ------------------------------------------------------------------------
-
-
-// exported classes
-
-namespace std {
-
-  //multiset
-
-  template <class _Key, class _Compare = std::less<_Key>,
-	    class _Alloc = allocator<_Key> >
-  class multiset {
-  public:
-    typedef size_t size_type;
-    typedef ptrdiff_t difference_type;
-    typedef _Key value_type;
-    typedef _Key key_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;
-
-    %traits_swigtype(_Key);
-
-    %fragment(SWIG_Traits_frag(std::multiset<_Key, _Compare, _Alloc >), "header",
-	      fragment=SWIG_Traits_frag(_Key),
-	      fragment="StdMultisetTraits") {
-      namespace swig {
-	template <>  struct traits<std::multiset<_Key, _Compare, _Alloc > > {
-	  typedef pointer_category category;
-	  static const char* type_name() {
-	    return "std::multiset<" #_Key "," #_Compare "," #_Alloc " >";
-	  }
-	};
-      }
-    }
-
-    %typemap_traits_ptr(SWIG_TYPECHECK_MULTISET, std::multiset<_Key, _Compare, _Alloc >);
-
-    multiset( const _Compare& );
-
-#ifdef %swig_multiset_methods
-    // Add swig/language extra methods
-    %swig_multiset_methods(std::multiset<_Key, _Compare, _Alloc >);
-#endif
-  
-    %std_multiset_methods(multiset);
-  };
-}
diff --git a/share/swig/2.0.11/std/std_pair.i b/share/swig/2.0.11/std/std_pair.i
deleted file mode 100644
index 2743430..0000000
--- a/share/swig/2.0.11/std/std_pair.i
+++ /dev/null
@@ -1,163 +0,0 @@
-%include <std_common.i>
-
-%{
-#include <utility>
-%}
-
-
-namespace std {
-  template <class T, class U > struct pair {      
-    typedef T first_type;
-    typedef U second_type;
-    
-    %traits_swigtype(T);
-    %traits_swigtype(U);
-
-    %fragment(SWIG_Traits_frag(std::pair<T,U >), "header",
-	      fragment=SWIG_Traits_frag(T),
-	      fragment=SWIG_Traits_frag(U),
-	      fragment="StdPairTraits") {
-      namespace swig {
-	template <>  struct traits<std::pair<T,U > > {
-	  typedef pointer_category category;
-	  static const char* type_name() {
-	    return "std::pair<" #T "," #U " >";
-	  }
-	};
-      }
-    }
-
-#ifndef SWIG_STD_PAIR_ASVAL
-    %typemap_traits_ptr(SWIG_TYPECHECK_PAIR, std::pair<T,U >);
-#else
-    %typemap_traits(SWIG_TYPECHECK_PAIR, std::pair<T,U >);
-#endif
-
-    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;
-
-#ifdef %swig_pair_methods
-    // Add swig/language extra methods
-    %swig_pair_methods(std::pair<T,U >)
-#endif
-  };
-
-  // ***
-  // The following specializations should disappear or get
-  // simplified when a 'const SWIGTYPE*&' can be defined
-  // ***
-  template <class T, class U > struct pair<T, U*> {      
-    typedef T first_type;
-    typedef U* second_type;
-    
-    %traits_swigtype(T);
-    %traits_swigtype(U);
-      
-    %fragment(SWIG_Traits_frag(std::pair<T,U* >), "header",
-	      fragment=SWIG_Traits_frag(T),
-	      fragment=SWIG_Traits_frag(U),
-	      fragment="StdPairTraits") {
-      namespace swig {
-	template <>  struct traits<std::pair<T,U* > > {
-	  typedef pointer_category category;
-	  static const char* type_name() {
-	    return "std::pair<" #T "," #U " * >";
-	  }
-	};
-      }
-    }
-
-    %typemap_traits_ptr(SWIG_TYPECHECK_PAIR, std::pair<T,U* >);
-
-    pair();
-    pair(T __a, U* __b);
-    pair(const pair& __p);
-
-    T first;
-    U* second;
-
-#ifdef %swig_pair_methods
-    // Add swig/language extra methods
-    %swig_pair_methods(std::pair<T,U*>)
-#endif
-  };
-
-  template <class T, class U > struct pair<T*, U> {      
-    typedef T* first_type;
-    typedef U second_type;
-    
-    %traits_swigtype(T);
-    %traits_swigtype(U);
-      
-    %fragment(SWIG_Traits_frag(std::pair<T*,U >), "header",
-	      fragment=SWIG_Traits_frag(T),
-	      fragment=SWIG_Traits_frag(U),
-	      fragment="StdPairTraits") {
-      namespace swig {
-	template <>  struct traits<std::pair<T*,U > > {
-	  typedef pointer_category category;
-	  static const char* type_name() {
-	    return "std::pair<" #T " *," #U " >";
-	  }
-	};
-      }
-    }
-
-    %typemap_traits_ptr(SWIG_TYPECHECK_PAIR, std::pair<T*,U >);
-
-    pair();
-    pair(T* __a, U __b);
-    pair(const pair& __p);
-
-    T* first;
-    U second;
-
-#ifdef %swig_pair_methods
-    // Add swig/language extra methods
-    %swig_pair_methods(std::pair<T*,U >)
-#endif
-  };
-
-  template <class T, class U > struct pair<T*, U*> {
-    typedef T* first_type;
-    typedef U* second_type;
-
-    %traits_swigtype(T);
-    %traits_swigtype(U);
-      
-    %fragment(SWIG_Traits_frag(std::pair<T*,U* >), "header",
-	      fragment=SWIG_Traits_frag(T),
-	      fragment=SWIG_Traits_frag(U),
-	      fragment="StdPairTraits") {
-      namespace swig {
-	template <>  struct traits<std::pair<T*,U* > > {
-	  typedef pointer_category category;
-	  static const char* type_name() {
-	    return "std::pair<" #T " *," #U " * >";
-	  }
-	};
-      }
-    }
-
-    %typemap_traits(SWIG_TYPECHECK_PAIR, std::pair<T*,U* >);
-
-    pair();
-    pair(T* __a, U* __b);
-    pair(const pair& __p);
-
-    T* first;
-    U* second;
- 
-#ifdef %swig_pair_methods
-    // Add swig/language extra methods
-    %swig_pair_methods(std::pair<T*,U*>)
-#endif
-  };
-
-}
diff --git a/share/swig/2.0.11/std/std_queue.i b/share/swig/2.0.11/std/std_queue.i
deleted file mode 100644
index 42273ee..0000000
--- a/share/swig/2.0.11/std/std_queue.i
+++ /dev/null
@@ -1,129 +0,0 @@
-/**
- * @file   std_queue.i
- * @date   Sun May  6 01:48:07 2007
- * 
- * @brief  A wrapping of std::queue for Ruby.
- * 
- * 
- */
-
-%include <std_container.i>
-
-// Queue
-
-%define %std_queue_methods(queue...)
-  queue();
-  queue( const _Sequence& );
-
-  bool empty() const;
-  size_type size() const;
-  const value_type& front() const;
-  const value_type& back() const;
-  void pop();
-  void push( const value_type& );
-%enddef
-
-%define %std_queue_methods_val(queue...) 
-  %std_queue_methods(queue)
-%enddef
-
-// ------------------------------------------------------------------------
-// std::queue
-// 
-// const declarations are used to guess the intent of the function being
-// exported; therefore, the following rationale is applied:
-// 
-//   -- f(std::queue<T>), f(const std::queue<T>&):
-//      the parameter being read-only, either a sequence or a
-//      previously wrapped std::queue<T> can be passed.
-//   -- f(std::queue<T>&), f(std::queue<T>*):
-//      the parameter may be modified; therefore, only a wrapped std::queue
-//      can be passed.
-//   -- std::queue<T> f(), const std::queue<T>& f():
-//      the queue is returned by copy; therefore, a sequence of T:s 
-//      is returned which is most easily used in other functions
-//   -- std::queue<T>& f(), std::queue<T>* f():
-//      the queue is returned by reference; therefore, a wrapped std::queue
-//      is returned
-//   -- const std::queue<T>* f(), f(const std::queue<T>*):
-//      for consistency, they expect and return a plain queue pointer.
-// ------------------------------------------------------------------------
-
-%{
-#include <queue>
-%}
-
-// exported classes
-
-namespace std {
-
-  template<class _Tp, class _Sequence = std::deque<_Tp> > 
-  class queue {
-  public:
-    typedef size_t size_type;
-    typedef _Tp value_type;
-    typedef value_type& reference;
-    typedef const value_type& const_reference;
-    typedef _Sequence container_type;
-
-    %traits_swigtype(_Tp);
-
-    %fragment(SWIG_Traits_frag(std::queue<_Tp, _Sequence >), "header",
-	      fragment=SWIG_Traits_frag(_Tp),
-	      fragment="StdQueueTraits") {
-      namespace swig {
-	template <>  struct traits<std::queue<_Tp, _Sequence > > {
-	  typedef pointer_category category;
-	  static const char* type_name() {
-	    return "std::queue<" #_Tp "," #_Sequence " >";
-	  }
-	};
-      }
-    }
-
-    %typemap_traits_ptr(SWIG_TYPECHECK_QUEUE, std::queue<_Tp, _Sequence >);
-  
-#ifdef %swig_queue_methods
-    // Add swig/language extra methods
-    %swig_queue_methods(std::queue<_Tp, _Sequence >);
-#endif
-
-    %std_queue_methods(queue);
-  };
-
-  template<class _Tp, class _Sequence > 
-  class queue<_Tp*, _Sequence > {
-  public:
-    typedef size_t size_type;
-    typedef _Tp value_type;
-    typedef value_type& reference;
-    typedef const value_type& const_reference;
-    typedef _Sequence container_type;
-
-    %traits_swigtype(_Tp);
-
-    %fragment(SWIG_Traits_frag(std::queue<_Tp*, _Sequence >), "header",
-	      fragment=SWIG_Traits_frag(_Tp),
-	      fragment="StdQueueTraits") {
-      namespace swig {
-	template <>  struct traits<std::queue<_Tp*, _Sequence > > {
-	  typedef value_category category;
-	  static const char* type_name() {
-	    return "std::queue<" #_Tp "," #_Sequence " * >";
-	  }
-	};
-      }
-    }
-
-    %typemap_traits_ptr(SWIG_TYPECHECK_QUEUE, std::queue<_Tp*, _Sequence >);
-
-#ifdef %swig_queue_methods_val
-    // Add swig/language extra methods
-    %swig_queue_methods_val(std::queue<_Tp*, _Sequence >);
-#endif
-
-    %std_queue_methods_val(std::queue<_Tp*, _Sequence >);
-  };
-
-}
-
diff --git a/share/swig/2.0.11/std/std_set.i b/share/swig/2.0.11/std/std_set.i
deleted file mode 100644
index 16f0f14..0000000
--- a/share/swig/2.0.11/std/std_set.i
+++ /dev/null
@@ -1,119 +0,0 @@
-//
-// std::set
-//
-
-%include <std_container.i>
-%include <std_pair.i>
-
-// Set
-%define %std_set_methods_common(set...)
-  set();
-  set( const set& );
-
-  bool empty() const;
-  size_type size() const;
-  void clear();
-
-  void swap(set& v);
-
-
-  size_type erase(const key_type& x);
-  size_type count(const key_type& x) const;
-  
-#ifdef SWIG_EXPORT_ITERATOR_METHODS
-  class iterator;
-  class reverse_iterator;
-
-  iterator begin();
-  iterator end();
-  reverse_iterator rbegin();
-  reverse_iterator rend();
-
-  void erase(iterator pos);
-  void erase(iterator first, iterator last);
-
-  iterator find(const key_type& x);
-  iterator lower_bound(const key_type& x);
-  iterator upper_bound(const key_type& x);
-  std::pair<iterator,iterator> equal_range(const key_type& x);
-#endif
-%enddef
-
-%define %std_set_methods(set...)
-  %std_set_methods_common(set);
-#ifdef SWIG_EXPORT_ITERATOR_METHODS
-  std::pair<iterator,bool> insert(const value_type& __x);
-#endif
-%enddef
-
-// ------------------------------------------------------------------------
-// std::set
-// 
-// const declarations are used to guess the intent of the function being
-// exported; therefore, the following rationale is applied:
-// 
-//   -- f(std::set<T>), f(const std::set<T>&):
-//      the parameter being read-only, either a sequence or a
-//      previously wrapped std::set<T> can be passed.
-//   -- f(std::set<T>&), f(std::set<T>*):
-//      the parameter may be modified; therefore, only a wrapped std::set
-//      can be passed.
-//   -- std::set<T> f(), const std::set<T>& f():
-//      the set is returned by copy; therefore, a sequence of T:s 
-//      is returned which is most easily used in other functions
-//   -- std::set<T>& f(), std::set<T>* f():
-//      the set is returned by reference; therefore, a wrapped std::set
-//      is returned
-//   -- const std::set<T>* f(), f(const std::set<T>*):
-//      for consistency, they expect and return a plain set pointer.
-// ------------------------------------------------------------------------
-
-%{
-#include <set>
-%}
-
-// exported classes
-
-namespace std {
-
-  template <class _Key, class _Compare = std::less<_Key>,
-	    class _Alloc = allocator<_Key> >
-  class set {
-  public:
-    typedef size_t size_type;
-    typedef ptrdiff_t difference_type;
-    typedef _Key value_type;
-    typedef _Key key_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;
-
-    %traits_swigtype(_Key);
-
-    %fragment(SWIG_Traits_frag(std::set<_Key, _Compare, _Alloc >), "header",
-	      fragment=SWIG_Traits_frag(_Key),
-	      fragment="StdSetTraits") {
-      namespace swig {
-	template <>  struct traits<std::set<_Key, _Compare, _Alloc > > {
-	  typedef pointer_category category;
-	  static const char* type_name() {
-	    return "std::set<" #_Key "," #_Compare "," #_Alloc " >";
-	  }
-	};
-      }
-    }
-
-    %typemap_traits_ptr(SWIG_TYPECHECK_SET, std::set<_Key, _Compare, _Alloc >);
-
-    set( const _Compare& );
-
-#ifdef %swig_set_methods
-    // Add swig/language extra methods
-    %swig_set_methods(std::set<_Key, _Compare, _Alloc >);
-#endif
-  
-    %std_set_methods(set);
-  };
-}
diff --git a/share/swig/2.0.11/std/std_stack.i b/share/swig/2.0.11/std/std_stack.i
deleted file mode 100644
index fb900a5..0000000
--- a/share/swig/2.0.11/std/std_stack.i
+++ /dev/null
@@ -1,128 +0,0 @@
-/**
- * @file   std_stack.i
- * @date   Sun May  6 01:48:07 2007
- * 
- * @brief  A wrapping of std::stack for Ruby.
- * 
- * 
- */
-
-%include <std_container.i>
-
-// Stack
-
-%define %std_stack_methods(stack...)
-  stack();
-  stack( const _Sequence& );
-
-  bool empty() const;
-  size_type size() const;
-  const value_type& top() const;
-  void pop();
-  void push( const value_type& );
-%enddef
-
-%define %std_stack_methods_val(stack...) 
-  %std_stack_methods(stack)
-%enddef
-
-// ------------------------------------------------------------------------
-// std::stack
-// 
-// const declarations are used to guess the intent of the function being
-// exported; therefore, the following rationale is applied:
-// 
-//   -- f(std::stack<T>), f(const std::stack<T>&):
-//      the parameter being read-only, either a sequence or a
-//      previously wrapped std::stack<T> can be passed.
-//   -- f(std::stack<T>&), f(std::stack<T>*):
-//      the parameter may be modified; therefore, only a wrapped std::stack
-//      can be passed.
-//   -- std::stack<T> f(), const std::stack<T>& f():
-//      the stack is returned by copy; therefore, a sequence of T:s 
-//      is returned which is most easily used in other functions
-//   -- std::stack<T>& f(), std::stack<T>* f():
-//      the stack is returned by reference; therefore, a wrapped std::stack
-//      is returned
-//   -- const std::stack<T>* f(), f(const std::stack<T>*):
-//      for consistency, they expect and return a plain stack pointer.
-// ------------------------------------------------------------------------
-
-%{
-#include <stack>
-%}
-
-// exported classes
-
-namespace std {
-
-  template<class _Tp, class _Sequence = std::deque<_Tp> > 
-  class stack {
-  public:
-    typedef size_t size_type;
-    typedef _Tp value_type;
-    typedef value_type& reference;
-    typedef const value_type& const_reference;
-    typedef _Sequence container_type;
-
-    %traits_swigtype(_Tp);
-
-    %fragment(SWIG_Traits_frag(std::stack<_Tp, _Sequence >), "header",
-	      fragment=SWIG_Traits_frag(_Tp),
-	      fragment="StdStackTraits") {
-      namespace swig {
-	template <>  struct traits<std::stack<_Tp, _Sequence > > {
-	  typedef pointer_category category;
-	  static const char* type_name() {
-	    return "std::stack<" #_Tp "," #_Sequence " >";
-	  }
-	};
-      }
-    }
-
-    %typemap_traits_ptr(SWIG_TYPECHECK_STACK, std::stack<_Tp, _Sequence >);
-  
-#ifdef %swig_stack_methods
-    // Add swig/language extra methods
-    %swig_stack_methods(std::stack<_Tp, _Sequence >);
-#endif
-
-    %std_stack_methods(stack);
-  };
-
-  template<class _Tp, class _Sequence > 
-  class stack<_Tp*, _Sequence > {
-  public:
-    typedef size_t size_type;
-    typedef _Sequence::value_type value_type;
-    typedef value_type reference;
-    typedef value_type const_reference;
-    typedef _Sequence container_type;
-
-    %traits_swigtype(_Tp);
-
-    %fragment(SWIG_Traits_frag(std::stack<_Tp*, _Sequence >), "header",
-	      fragment=SWIG_Traits_frag(_Tp),
-	      fragment="StdStackTraits") {
-      namespace swig {
-	template <>  struct traits<std::stack<_Tp*, _Sequence > > {
-	  typedef value_category category;
-	  static const char* type_name() {
-	    return "std::stack<" #_Tp "," #_Sequence " * >";
-	  }
-	};
-      }
-    }
-
-    %typemap_traits_ptr(SWIG_TYPECHECK_STACK, std::stack<_Tp*, _Sequence >);
-
-#ifdef %swig_stack_methods_val
-    // Add swig/language extra methods
-    %swig_stack_methods_val(std::stack<_Tp*, _Sequence >);
-#endif
-
-    %std_stack_methods_val(std::stack<_Tp*, _Sequence >);
-  };
-
-}
-
diff --git a/share/swig/2.0.11/std/std_vector.i b/share/swig/2.0.11/std/std_vector.i
deleted file mode 100644
index baecf85..0000000
--- a/share/swig/2.0.11/std/std_vector.i
+++ /dev/null
@@ -1,225 +0,0 @@
-//
-// std::vector
-//
-
-%include <std_container.i>
-
-// Vector
-
-%define %std_vector_methods(vector...)
-  %std_sequence_methods(vector)
-  
-  void reserve(size_type n);
-  size_type capacity() const;
-%enddef
-
-
-%define %std_vector_methods_val(vector...)
-  %std_sequence_methods_val(vector)
-  
-  void reserve(size_type n);
-  size_type capacity() const;
-%enddef
-
-
-// ------------------------------------------------------------------------
-// std::vector
-// 
-// The aim of all that follows would be to integrate std::vector with 
-// as much as possible, namely, to allow the user to pass and 
-// be returned tuples or lists.
-// const declarations are used to guess the intent of the function being
-// exported; therefore, the following rationale is applied:
-// 
-//   -- f(std::vector<T>), f(const std::vector<T>&):
-//      the parameter being read-only, either a sequence or a
-//      previously wrapped std::vector<T> can be passed.
-//   -- f(std::vector<T>&), f(std::vector<T>*):
-//      the parameter may be modified; therefore, only a wrapped std::vector
-//      can be passed.
-//   -- std::vector<T> f(), const std::vector<T>& f():
-//      the vector is returned by copy; therefore, a sequence of T:s 
-//      is returned which is most easily used in other functions
-//   -- std::vector<T>& f(), std::vector<T>* f():
-//      the vector is returned by reference; therefore, a wrapped std::vector
-//      is returned
-//   -- const std::vector<T>* f(), f(const std::vector<T>*):
-//      for consistency, they expect and return a plain vector pointer.
-// ------------------------------------------------------------------------
-
-%{
-#include <vector>
-%}    
-
-// exported classes
-
-
-namespace std {
-
-  template<class _Tp, class _Alloc = allocator< _Tp > >
-  class vector {
-  public:
-    typedef size_t size_type;
-    typedef ptrdiff_t difference_type;
-    typedef _Tp value_type;
-    typedef value_type* pointer;
-    typedef const value_type* const_pointer;
-    typedef _Tp& reference;
-    typedef const _Tp& const_reference;
-    typedef _Alloc allocator_type;
-
-    %traits_swigtype(_Tp);
-    %traits_enum(_Tp);
-
-    %fragment(SWIG_Traits_frag(std::vector<_Tp, _Alloc >), "header",
-	      fragment=SWIG_Traits_frag(_Tp),
-	      fragment="StdVectorTraits") {
-      namespace swig {
-	template <>  struct traits<std::vector<_Tp, _Alloc > > {
-	  typedef pointer_category category;
-	  static const char* type_name() {
-	    return "std::vector<" #_Tp "," #_Alloc " >";
-	  }
-	};
-      }
-    }
-
-    %typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<_Tp, _Alloc >);
-
-#ifdef %swig_vector_methods
-    // Add swig/language extra methods
-    %swig_vector_methods(std::vector<_Tp, _Alloc >);
-#endif
-  
-    %std_vector_methods(vector);
-  };
-
-  // ***
-  // This specialization should disappear or get simplified when
-  // a 'const SWIGTYPE*&' can be defined
-  // ***
-  template<class _Tp, class _Alloc >
-  class vector<_Tp*, _Alloc > {
-  public:
-    typedef size_t size_type;    
-    typedef ptrdiff_t difference_type;
-    typedef _Tp* value_type;
-    typedef value_type* pointer;
-    typedef const value_type* const_pointer;
-    typedef value_type reference;
-    typedef value_type const_reference;
-    typedef _Alloc allocator_type;
-
-    %traits_swigtype(_Tp);
-
-    %fragment(SWIG_Traits_frag(std::vector<_Tp*, _Alloc >), "header",
-	      fragment=SWIG_Traits_frag(_Tp),
-	      fragment="StdVectorTraits") {
-      namespace swig {
-	template <>  struct traits<std::vector<_Tp*, _Alloc > > {
-	  typedef value_category category;
-	  static const char* type_name() {
-	    return "std::vector<" #_Tp " *," #_Alloc " >";
-	  }
-	};
-      }
-    }
-
-    %typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<_Tp*, _Alloc >);
-
-#ifdef %swig_vector_methods_val
-    // Add swig/language extra methods
-    %swig_vector_methods_val(std::vector<_Tp*, _Alloc >);
-#endif
-
-    %std_vector_methods_val(vector);
-  };
-
-  // ***
-  // const pointer specialization
-  // ***
-  template<class _Tp, class _Alloc >
-  class vector<_Tp const *, _Alloc > {
-  public:
-    typedef size_t size_type;    
-    typedef ptrdiff_t difference_type;
-    typedef _Tp const * value_type;
-    typedef value_type* pointer;
-    typedef const value_type* const_pointer;
-    typedef value_type reference;
-    typedef value_type const_reference;
-    typedef _Alloc allocator_type;
-
-    %traits_swigtype(_Tp);
-
-    %fragment(SWIG_Traits_frag(std::vector<_Tp const*, _Alloc >), "header",
-	      fragment=SWIG_Traits_frag(_Tp),
-	      fragment="StdVectorTraits") {
-      namespace swig {
-	template <>  struct traits<std::vector<_Tp const*, _Alloc > > {
-	  typedef value_category category;
-	  static const char* type_name() {
-	    return "std::vector<" #_Tp " const*," #_Alloc " >";
-	  }
-	};
-      }
-    }
-
-    %typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<_Tp const*, _Alloc >);
-
-#ifdef %swig_vector_methods_val
-    // Add swig/language extra methods
-    %swig_vector_methods_val(std::vector<_Tp const*, _Alloc >);
-#endif
-
-    %std_vector_methods_val(vector);
-  };
-
-  // ***
-  // bool specialization
-  // ***
-
-  template<class _Alloc > 
-  class vector<bool,_Alloc > {
-  public:
-    typedef size_t size_type;    
-    typedef ptrdiff_t difference_type;
-    typedef bool value_type;
-    typedef value_type* pointer;
-    typedef const value_type* const_pointer;
-    typedef value_type reference;
-    typedef value_type const_reference;
-    typedef _Alloc allocator_type;
-
-    %traits_swigtype(bool);
-
-    %fragment(SWIG_Traits_frag(std::vector<bool, _Alloc >), "header",
-	      fragment=SWIG_Traits_frag(bool),
-	      fragment="StdVectorTraits") {
-      namespace swig {
-	template <>  struct traits<std::vector<bool, _Alloc > > {
-	  typedef value_category category;
-	  static const char* type_name() {
-	    return "std::vector<bool, _Alloc >";
-	  }
-	};
-      }
-    }
-
-    %typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<bool, _Alloc >);
-
-
-#ifdef %swig_vector_methods_val
-    // Add swig/language extra methods
-    %swig_vector_methods_val(std::vector<bool, _Alloc >);
-#endif
-
-    %std_vector_methods_val(vector);
-
-#if defined(SWIG_STD_MODERN_STL) && !defined(SWIG_STD_NOMODERN_STL) 
-    void flip();
-#endif
-
-  };
-
-}
diff --git a/share/swig/2.0.11/std_except.i b/share/swig/2.0.11/std_except.i
deleted file mode 100644
index a4a7a85..0000000
--- a/share/swig/2.0.11/std_except.i
+++ /dev/null
@@ -1,55 +0,0 @@
-/* -----------------------------------------------------------------------------
- * std_except.i
- *
- * SWIG library file with typemaps to handle and throw STD exceptions in a
- * language and STL independent way, i.e., the target language doesn't
- * require to support STL but only the 'exception.i' mechanism.
- *
- * These typemaps are used when methods are declared with an STD
- * exception specification, such as
- *
- *   size_t at() const throw (std::out_of_range);
- *
- * The typemaps here are based on the language independent
- * 'exception.i' library. If that is working in your target language,
- * this file will work.
- * 
- * If the target language doesn't implement a robust 'exception.i'
- * mechanism, or you prefer other ways to map the STD exceptions, write
- * a new std_except.i file in the target library directory.
- * ----------------------------------------------------------------------------- */
-
-#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGGUILE) || defined(SWIGUTL) || defined(SWIGD)
-#error "This version of std_except.i should not be used"
-#endif
-
-%{
-#include <stdexcept>
-%}
-
-%include <exception.i>
-
-
-%define %std_exception_map(Exception, Code)
-  %typemap(throws,noblock=1) Exception {
-    SWIG_exception(Code, $1.what());
-  }
-  %ignore Exception;
-  struct Exception {
-  };
-%enddef
-
-namespace std {
-  %std_exception_map(bad_exception,      SWIG_SystemError);
-  %std_exception_map(domain_error,       SWIG_ValueError);
-  %std_exception_map(exception,          SWIG_SystemError);
-  %std_exception_map(invalid_argument,   SWIG_ValueError);
-  %std_exception_map(length_error,       SWIG_IndexError);
-  %std_exception_map(logic_error,        SWIG_RuntimeError);
-  %std_exception_map(out_of_range,       SWIG_IndexError);
-  %std_exception_map(overflow_error,     SWIG_OverflowError);
-  %std_exception_map(range_error,        SWIG_OverflowError);
-  %std_exception_map(runtime_error,      SWIG_RuntimeError);
-  %std_exception_map(underflow_error,    SWIG_OverflowError);
-}
-
diff --git a/share/swig/2.0.11/swig.swg b/share/swig/2.0.11/swig.swg
deleted file mode 100644
index 97e7c80..0000000
--- a/share/swig/2.0.11/swig.swg
+++ /dev/null
@@ -1,689 +0,0 @@
-/* -----------------------------------------------------------------------------
- * swig.swg
- *
- * Common macro definitions for various SWIG directives.  This file is always 
- * included at the top of each input file.
- * ----------------------------------------------------------------------------- */
-
-/* -----------------------------------------------------------------------------
- * User Directives 
- * ----------------------------------------------------------------------------- */
-
-/* Deprecated SWIG directives */
-
-#define %disabledoc     %warn "104:%disabledoc is deprecated"
-#define %enabledoc      %warn "105:%enabledoc is deprecated"
-#define %doconly        %warn "106:%doconly is deprecated"
-#define %style          %warn "107:%style is deprecated" /##/
-#define %localstyle     %warn "108:%localstyle is deprecated" /##/
-#define %title          %warn "109:%title is deprecated" /##/
-#define %section        %warn "110:%section is deprecated" /##/
-#define %subsection     %warn "111:%subsection is deprecated" /##/
-#define %subsubsection  %warn "112:%subsubsection is deprecated" /##/
-#define %new            %warn "117:%new is deprecated. Use %newobject"
-#define %text           %insert("null")
-
-/* Code insertion directives such as %wrapper %{ ... %} */
-
-#define %begin       %insert("begin")
-#define %runtime     %insert("runtime")
-#define %header      %insert("header")
-#define %wrapper     %insert("wrapper")
-#define %init        %insert("init")
-
-/* Class extension */
-
-#define %addmethods  %warn "113:%addmethods is now %extend" %extend
-
-/* %ignore directive */
-
-#define %ignore         %rename($ignore)
-#define %ignorewarn(x)  %rename("$ignore:" x)
-
-/* Access control directives */
-
-#define %readonly    %warn "114:%readonly is deprecated. Use %immutable; " %feature("immutable");
-#define %readwrite   %warn "115:%readwrite is deprecated. Use %mutable; " %feature("immutable","");
-
-#define %immutable       %feature("immutable")
-#define %noimmutable     %feature("immutable","0")
-#define %clearimmutable  %feature("immutable","")
-#define %mutable         %clearimmutable
-
-/* Generation of default constructors/destructors (old form, don't use) */
-#define %nodefault       %feature("nodefault","1")
-#define %default         %feature("nodefault","0")
-#define %clearnodefault  %feature("nodefault","")
-#define %makedefault     %clearnodefault
-
-/* Disable the generation of implicit default constructor */
-#define %nodefaultctor       %feature("nodefaultctor","1")
-#define %defaultctor         %feature("nodefaultctor","0")
-#define %clearnodefaultctor  %feature("nodefaultctor","")
-
-/* Disable the generation of implicit default destructor (dangerous) */
-#define %nodefaultdtor       %feature("nodefaultdtor","1")
-#define %defaultdtor         %feature("nodefaultdtor","0")
-#define %clearnodefaultdtor  %feature("nodefaultdtor","")
-
-/* Enable the generation of copy constructor */
-#define %copyctor       %feature("copyctor","1")
-#define %nocopyctor     %feature("copyctor","0")
-#define %clearcopyctor  %feature("copyctor","")
-
-/* Force the old nodefault behavior, ie disable both constructor and destructor */
-#define %oldnodefault       %feature("oldnodefault","1")
-#define %nooldnodefault     %feature("oldnodefault","0")
-#define %clearoldnodefault  %feature("oldnodefault","")
-
-/* the %exception directive */
-#if defined(SWIGCSHARP) || defined(SWIGD)
-#define %exception      %feature("except", canthrow=1)
-#else
-#define %exception      %feature("except")
-#endif
-#define %noexception    %feature("except","0")
-#define %clearexception %feature("except","")
-
-/* the %allowexception directive allows the %exception feature to
-   be applied to set/get variable methods */
-#define %allowexception      %feature("allowexcept")
-#define %noallowexception    %feature("allowexcept","0")
-#define %clearallowexception %feature("allowexcept","")
-
-/* the %exceptionvar directive, as %exception but it is only applied
-   to set/get variable methods. You don't need to use the
-   %allowexception directive when using %exceptionvar.
-*/
-#if defined(SWIGCSHARP) || defined(SWIGD)
-#define %exceptionvar      %feature("exceptvar", canthrow=1)
-#else
-#define %exceptionvar      %feature("exceptvar")
-#endif
-#define %noexceptionvar    %feature("exceptvar","0")
-#define %clearexceptionvar %feature("exceptvar","")
-
-/* the %catches directive */
-#define %catches(tlist...)    %feature("catches","("`tlist`")")
-#define %clearcatches         %feature("catches","")
-
-/* the %exceptionclass directive */
-#define %exceptionclass      %feature("exceptionclass")
-#define %noexceptionclass    %feature("exceptionclass","0")
-#define %clearexceptionclass %feature("exceptionclass","")
-
-/* the %newobject directive */
-#define %newobject        %feature("new")
-#define %nonewobject      %feature("new","0")
-#define %clearnewobject   %feature("new","")
-
-/* the %delobject directive */
-#define %delobject        %feature("del")
-#define %nodelobject      %feature("del","0")
-#define %cleardelobject   %feature("del","")
-
-/* the %refobject/%unrefobject directives */
-#define %refobject         %feature("ref")
-#define %norefobject       %feature("ref","0")
-#define %clearrefobject    %feature("ref","")
-
-#define %unrefobject       %feature("unref")
-#define %nounrefobject     %feature("unref","0")
-#define %clearunrefobject  %feature("unref","")
-
-/* Directives for callback functions (experimental) */
-#define %callback(x)    %feature("callback",`x`)
-#define %nocallback     %feature("callback","0")
-#define %clearcallback  %feature("callback","")
-
-/* the %nestedworkaround directive */
-#define %nestedworkaround       %feature("nestedworkaround")
-#define %nonestedworkaround     %feature("nestedworkaround","0")
-#define %clearnestedworkaround  %feature("nestedworkaround","")
-
-/* the %fastdispatch directive */
-#define %fastdispatch        %feature("fastdispatch")
-#define %nofastdispatch      %feature("fastdispatch","0")
-#define %clearfastdispatch   %feature("fastdispatch","")
-
-/* directors directives */
-#define %director      %feature("director")
-#define %nodirector    %feature("director","0")
-#define %cleardirector %feature("director","")
-
-/* naturalvar directives */
-#define %naturalvar      %feature("naturalvar")
-#define %nonaturalvar    %feature("naturalvar","0")
-#define %clearnaturalvar %feature("naturalvar","")
-
-/* nspace directives */
-#define %nspace      %feature("nspace")
-#define %nonspace    %feature("nspace","0")
-#define %clearnspace %feature("nspace","")
-
-/* valuewrapper directives */
-#define %valuewrapper        %feature("valuewrapper")
-#define %clearvaluewrapper   %feature("valuewrapper","")
-#define %novaluewrapper      %feature("novaluewrapper")
-#define %clearnovaluewrapper %feature("novaluewrapper","")
-
-/* Contract support - Experimental and undocumented */
-#define %contract      %feature("contract")
-#define %nocontract    %feature("contract","0")
-#define %clearcontract %feature("contract","")
-
-/* Macro for setting a dynamic cast function */
-%define DYNAMIC_CAST(mangle,func)
-%init %{
-   mangle->dcast = (swig_dycast_func) func;
-%}
-%enddef
-
-/* aggregation support */
-/*
-  This macro performs constant aggregation.  Basically the idea of
-  constant aggregation is that you can group a collection of constants
-  together.  For example, suppose you have some code like this:
-
-       #define UP  1
-       #define DOWN 2
-       #define LEFT 3
-       #define RIGHT 4
-
-  Now, suppose you had a function like this:
-
-       int move(int direction)
-
-  In this case, you might want to restrict the direction argument to
-  one of the supplied constant names. To do this, you could write some
-  typemap code by hand.  Alternatively, you can use the
-  %aggregate_check macro defined here to create a simple check
-  function for you.  Here is an example:
-
-    %aggregate_check(int, check_direction, UP, DOWN, LEFT, RIGHT);
-
-  Now, using a typemap
-
-    %typemap(check) int direction {
-      if (!check_direction($1)) SWIG_exception(SWIG_ValueError,"Bad direction.");
-    }
-
-  or a contract (better)
-
-    %contract move(int x) {
-    require:
-        check_direction(x);
-    }
-
-*/
-   
-%define %aggregate_check(TYPE, NAME, FIRST, ...)
-%wrapper %{
-static int NAME(TYPE x) {
-    static  TYPE values[] = { FIRST, ##__VA_ARGS__ };
-    static  int size = sizeof(values);
-    int     i,j;
-    for (i = 0, j = 0; i < size; i+=sizeof(TYPE),j++) {
-        if (x == values[j]) return 1; 
-    }
-    return 0;
-}
-%}
-%enddef
-
-
-/* -----------------------------------------------------------------------------
- * %rename predicates
- * ----------------------------------------------------------------------------- */
-/* 
-   Predicates to be used with %rename, for example:
-
-   - to rename all the functions:
-
-     %rename("%(utitle)s", %$isfunction) "";
-
-   - to rename only the member methods:
-
-     %rename("m_%(utitle)s", %$isfunction, %$ismember) "";
-
-   - to rename only the global functions:
-
-      %rename("m_%(utitle)s", %$isfunction, %$not %$ismember) "";
-
-     or
-
-      %rename("g_%(utitle)s", %$isfunction, %$isglobal) "";
-
-   - to ignore the enumitems in a given class:
-
-     %rename("$ignore", %$isenumitem, %$classname="MyClass") "";
-
-   we use the prefix '%$' to avoid clashings with other swig
-   macros/directives.
-
-*/
-
-%define %$not            "not" %enddef 
-%define %$isenum         "match"="enum"  %enddef
-%define %$isenumitem     "match"="enumitem"  %enddef
-%define %$isaccess       "match"="access"   %enddef
-%define %$isclass        "match"="class","notmatch$template$templatetype"="class"   %enddef
-%define %$isextend       "match"="extend"  %enddef
-%define %$isconstructor  "match"="constructor"  %enddef
-%define %$isdestructor   "match"="destructor"  %enddef
-%define %$isnamespace    "match"="namespace"  %enddef
-%define %$istemplate     "match"="template"  %enddef
-%define %$isconstant     "match"="constant"  %enddef  /* %constant definition */
-
-%define %$isunion        "match$kind"="union"  %enddef
-%define %$isfunction     "match$kind"="function"  %enddef
-%define %$isvariable     "match$kind"="variable"  %enddef
-%define %$isimmutable    "match$feature:immutable"="1"  %enddef
-%define %$hasconsttype   "match$hasconsttype"="1"  %enddef
-%define %$hasvalue       "match$hasvalue"="1"  %enddef
-%define %$isextension    "match$isextension"="1"  %enddef
-
-%define %$isstatic       "match$storage"="static"  %enddef
-%define %$isfriend       "match$storage"="friend"  %enddef
-%define %$istypedef      "match$storage"="typedef"  %enddef
-%define %$isvirtual      "match$storage"="virtual"  %enddef
-%define %$isexplicit     "match$storage"="explicit"  %enddef
-%define %$isextern       "match$storage"="extern"  %enddef
-
-%define %$ismember       "match$ismember"="1"  %enddef
-%define %$isglobal       %$not %$ismember  %enddef
-%define %$innamespace    "match$parentNode$nodeType"="namespace"  %enddef
-
-%define %$ispublic       "match$access"="public"  %enddef
-%define %$isprotected    "match$access"="protected"  %enddef
-%define %$isprivate      "match$access"="private"  %enddef
-
-%define %$ismemberget    "match$memberget"="1"  %enddef
-%define %$ismemberset    "match$memberset"="1"  %enddef
-
-%define %$classname      %$ismember,"match$parentNode$name"  %enddef
-
-/* -----------------------------------------------------------------------------
- * Include all the warnings labels and macros 
- * ----------------------------------------------------------------------------- */
-
-%include <swigwarnings.swg>
-
-/* -----------------------------------------------------------------------------
- * Default handling of certain overloaded operators 
- * ----------------------------------------------------------------------------- */
-
-#ifdef __cplusplus
-%ignoreoperator(NEW)     operator new;
-%ignoreoperator(DELETE)  operator delete;
-%ignoreoperator(NEWARR)  operator new[];
-%ignoreoperator(DELARR)  operator delete[];
-
-/* add C++ operator aliases */
-%rename("operator &&") operator and;    // `and'    `&&'
-%rename("operator ||") operator or;     // `or'     `||'
-%rename("operator !")  operator not;    // `not'     `!'
-%rename("operator &=") operator and_eq; // `and_eq'  `&='
-%rename("operator &")  operator bitand; // `bitand'  `&'
-%rename("operator |")  operator bitor;  // `bitor'   `|'
-%rename("operator ~")  operator compl;  // `compl'   `~'
-%rename("operator !=") operator not_eq; // `not_eq'  `!='
-%rename("operator |=") operator or_eq;  // `or_eq'   `|='
-%rename("operator ^")  operator xor;    // `xor'     `^'
-%rename("operator ^=") operator xor_eq; // `xor_eq'  `^='
-
-/* Smart pointer handling */
-
-%rename(__deref__) *::operator->;
-%rename(__ref__)   *::operator*();
-%rename(__ref__)   *::operator*() const;
-
-/* Define std namespace */
-namespace std {
-}
-#endif
-
-/* -----------------------------------------------------------------------------
- * Default char * and C array typemaps
- * ----------------------------------------------------------------------------- */
-
-/* Set up the typemap for handling new return strings */
-
-#ifdef __cplusplus
-%typemap(newfree) char * "delete [] $1;";
-#else
-%typemap(newfree) char * "free($1);";
-#endif
-
-/* Default typemap for handling char * members */
-
-#ifdef __cplusplus
-%typemap(memberin) char * {
-  delete [] $1;
-  if ($input) {
-     $1 = ($1_type) (new char[strlen((const char *)$input)+1]);
-     strcpy((char *)$1, (const char *)$input);
-  } else {
-     $1 = 0;
-  }
-}
-%typemap(memberin,warning=SWIGWARN_TYPEMAP_CHARLEAK_MSG) const char * {
-  if ($input) {
-     $1 = ($1_type) (new char[strlen((const char *)$input)+1]);
-     strcpy((char *)$1, (const char *)$input);
-  } else {
-     $1 = 0;
-  }
-}
-%typemap(globalin) char * {
-  delete [] $1;
-  if ($input) {
-     $1 = ($1_type) (new char[strlen((const char *)$input)+1]);
-     strcpy((char *)$1, (const char *)$input);
-  } else {
-     $1 = 0;
-  }
-}
-%typemap(globalin,warning=SWIGWARN_TYPEMAP_CHARLEAK_MSG) const char * {
-  if ($input) {
-     $1 = ($1_type) (new char[strlen((const char *)$input)+1]);
-     strcpy((char *)$1, (const char *)$input);
-  } else {
-     $1 = 0;
-  }
-}
-#else
-%typemap(memberin) char * {
-  free($1);
-  if ($input) {
-     $1 = ($1_type) malloc(strlen((const char *)$input)+1);
-     strcpy((char *)$1, (const char *)$input);
-  } else {
-     $1 = 0;
-  }
-}
-%typemap(memberin,warning=SWIGWARN_TYPEMAP_CHARLEAK_MSG) const char * {
-  if ($input) {
-     $1 = ($1_type) malloc(strlen((const char *)$input)+1);
-     strcpy((char *)$1, (const char *)$input);
-  } else {
-     $1 = 0;
-  }
-}
-%typemap(globalin) char * {
-  free($1);
-  if ($input) {
-     $1 = ($1_type) malloc(strlen((const char *)$input)+1);
-     strcpy((char *)$1, (const char *)$input);
-  } else {
-     $1 = 0;
-  }
-}
-%typemap(globalin,warning=SWIGWARN_TYPEMAP_CHARLEAK_MSG) const char * {
-  if ($input) {
-     $1 = ($1_type) malloc(strlen((const char *)$input)+1);
-     strcpy((char *)$1, (const char *)$input);
-  } else {
-     $1 = 0;
-  }
-}
-
-#endif
-
-/* Character array handling */
-
-%typemap(memberin) char [ANY] {
-  if($input) {
-    strncpy((char*)$1, (const char *)$input, $1_dim0-1);
-    $1[$1_dim0-1] = 0;
-  } else {
-    $1[0] = 0;
-  }
-}
-
-%typemap(globalin) char [ANY] {
-  if($input) {
-    strncpy((char*)$1, (const char *)$input, $1_dim0-1);
-    $1[$1_dim0-1] = 0;
-  } else {
-    $1[0] = 0;
-  }
-}
-
-%typemap(memberin) char [] {
-  if ($input) strcpy((char *)$1, (const char *)$input);
-  else $1[0] = 0;
-}
-
-%typemap(globalin) char [] {
-  if ($input) strcpy((char *)$1, (const char *)$input);
-  else $1[0] = 0;
-}
-
-/* memberin/globalin typemap for arrays. */
-
-%typemap(memberin) SWIGTYPE [ANY] {
-  size_t ii;
-  $1_basetype *b = ($1_basetype *) $1;
-  for (ii = 0; ii < (size_t)$1_size; ii++) b[ii] = *(($1_basetype *) $input + ii);
-}
-
-%typemap(globalin) SWIGTYPE [ANY] {
-  size_t ii;
-  $1_basetype *b = ($1_basetype *) $1;
-  for (ii = 0; ii < (size_t)$1_size; ii++) b[ii] = *(($1_basetype *) $input + ii);
-}
-
-/* memberin/globalin typemap for double arrays. */
-
-%typemap(memberin) SWIGTYPE [ANY][ANY] {
-  $basetype (*inp)[$1_dim1] = ($basetype (*)[$1_dim1])($input);
-  $basetype (*dest)[$1_dim1] = ($basetype (*)[$1_dim1])($1);
-  size_t ii = 0;
-  for (; ii < $1_dim0; ++ii) {
-    $basetype *ip = inp[ii];
-    $basetype *dp = dest[ii];
-    size_t jj = 0;
-    for (; jj < $1_dim1; ++jj) dp[jj] = ip[jj];
-  }
-}
-
-%typemap(globalin) SWIGTYPE [ANY][ANY] {
-  $basetype (*inp)[$1_dim1] = ($basetype (*)[$1_dim1])($input);
-  $basetype (*dest)[$1_dim1] = ($basetype (*)[$1_dim1])($1);
-  size_t ii = 0;
-  for (; ii < $1_dim0; ++ii) {
-    $basetype *ip = inp[ii];
-    $basetype *dp = dest[ii];
-    size_t jj = 0;
-    for (; jj < $1_dim1; ++jj) dp[jj] = ip[jj];
-  }
-}
-
-/* -----------------------------------------------------------------------------
- * Overloading support
- * ----------------------------------------------------------------------------- */
-
-/*
- * Function/method overloading support.   This is done through typemaps,
- * but also involve a precedence level. 
- */
-
-/* Macro for overload resolution */
-
-%define %typecheck(_x...) %typemap(typecheck, precedence=_x) %enddef
-
-/* Macros for precedence levels */
-
-%define SWIG_TYPECHECK_POINTER       0     %enddef
-%define SWIG_TYPECHECK_ITERATOR      5     %enddef
-%define SWIG_TYPECHECK_VOIDPTR       10    %enddef
-%define SWIG_TYPECHECK_BOOL          15    %enddef
-%define SWIG_TYPECHECK_UINT8         20    %enddef
-%define SWIG_TYPECHECK_INT8          25    %enddef
-%define SWIG_TYPECHECK_UINT16        30    %enddef
-%define SWIG_TYPECHECK_INT16         35    %enddef
-%define SWIG_TYPECHECK_UINT32        40    %enddef
-%define SWIG_TYPECHECK_INT32         45    %enddef
-%define SWIG_TYPECHECK_SIZE          47    %enddef
-%define SWIG_TYPECHECK_PTRDIFF       48    %enddef
-%define SWIG_TYPECHECK_UINT64        50    %enddef
-%define SWIG_TYPECHECK_INT64         55    %enddef
-%define SWIG_TYPECHECK_UINT128       60    %enddef
-%define SWIG_TYPECHECK_INT128        65    %enddef
-%define SWIG_TYPECHECK_INTEGER       70    %enddef
-%define SWIG_TYPECHECK_FLOAT         80    %enddef
-%define SWIG_TYPECHECK_DOUBLE        90    %enddef
-%define SWIG_TYPECHECK_CPLXFLT       95    %enddef
-%define SWIG_TYPECHECK_CPLXDBL      100    %enddef
-%define SWIG_TYPECHECK_COMPLEX      105    %enddef
-%define SWIG_TYPECHECK_UNICHAR      110    %enddef
-%define SWIG_TYPECHECK_STDUNISTRING 115    %enddef
-%define SWIG_TYPECHECK_UNISTRING    120    %enddef
-%define SWIG_TYPECHECK_CHAR         130    %enddef
-%define SWIG_TYPECHECK_STDSTRING    135    %enddef
-%define SWIG_TYPECHECK_STRING       140    %enddef
-%define SWIG_TYPECHECK_PAIR         150    %enddef
-%define SWIG_TYPECHECK_VECTOR       160    %enddef
-%define SWIG_TYPECHECK_DEQUE        170    %enddef
-%define SWIG_TYPECHECK_LIST         180    %enddef
-%define SWIG_TYPECHECK_SET          190    %enddef
-%define SWIG_TYPECHECK_MULTISET     200    %enddef
-%define SWIG_TYPECHECK_MAP          210    %enddef
-%define SWIG_TYPECHECK_MULTIMAP     220    %enddef
-%define SWIG_TYPECHECK_STACK        230    %enddef
-%define SWIG_TYPECHECK_QUEUE        240    %enddef
-
-%define SWIG_TYPECHECK_BOOL_ARRAY        1015    %enddef
-%define SWIG_TYPECHECK_INT8_ARRAY        1025    %enddef
-%define SWIG_TYPECHECK_INT16_ARRAY       1035    %enddef
-%define SWIG_TYPECHECK_INT32_ARRAY       1045    %enddef
-%define SWIG_TYPECHECK_INT64_ARRAY       1055    %enddef
-%define SWIG_TYPECHECK_INT128_ARRAY      1065    %enddef
-%define SWIG_TYPECHECK_FLOAT_ARRAY       1080    %enddef
-%define SWIG_TYPECHECK_DOUBLE_ARRAY      1090    %enddef
-%define SWIG_TYPECHECK_CHAR_ARRAY        1130    %enddef
-%define SWIG_TYPECHECK_STRING_ARRAY      1140    %enddef
-%define SWIG_TYPECHECK_OBJECT_ARRAY      1150    %enddef
-
-%define SWIG_TYPECHECK_BOOL_PTR          2015    %enddef
-%define SWIG_TYPECHECK_UINT8_PTR         2020    %enddef
-%define SWIG_TYPECHECK_INT8_PTR          2025    %enddef
-%define SWIG_TYPECHECK_UINT16_PTR        2030    %enddef
-%define SWIG_TYPECHECK_INT16_PTR         2035    %enddef
-%define SWIG_TYPECHECK_UINT32_PTR        2040    %enddef
-%define SWIG_TYPECHECK_INT32_PTR         2045    %enddef
-%define SWIG_TYPECHECK_UINT64_PTR        2050    %enddef
-%define SWIG_TYPECHECK_INT64_PTR         2055    %enddef
-%define SWIG_TYPECHECK_FLOAT_PTR         2080    %enddef
-%define SWIG_TYPECHECK_DOUBLE_PTR        2090    %enddef
-%define SWIG_TYPECHECK_CHAR_PTR          2130    %enddef
-
-
-%define SWIG_TYPECHECK_SWIGOBJECT        5000    %enddef
-
-
-/* -----------------------------------------------------------------------------
- *  Runtime code
- * ----------------------------------------------------------------------------- */
-
-/*  The SwigValueWrapper class  */
-
-/*  
- * This template wrapper is used to handle C++ objects that are passed or 
- * returned by value.   This is necessary to handle objects that define
- * no default-constructor (making it difficult for SWIG to properly declare
- * local variables).
- *
- * The wrapper is used as follows.  First consider a function like this:
- *
- *      Vector cross_product(Vector a, Vector b)
- *
- * Now, if Vector is defined as a C++ class with no default constructor, 
- * code is generated as follows:
- *
- *     Vector *wrap_cross_product(Vector *inarg1, Vector *inarg2) {
- *          SwigValueWrapper<Vector>  arg1;
- *          SwigValueWrapper<Vector>  arg2;
- *          SwigValueWrapper<Vector> result;
- *
- *          arg1 = *inarg1;
- *          arg2 = *inarg2;
- *          ...            
- *          result = cross_product(arg1,arg2);
- *          ...
- *          return new Vector(result);
- *    }
- *         
- * In the wrappers, the template SwigValueWrapper simply provides a thin
- * layer around a Vector *.  However, it does this in a way that allows
- * the object to be bound after the variable declaration (which is not possible
- * with the bare object when it lacks a default constructor).  
- *
- * An observant reader will notice that the code after the variable declarations
- * is *identical* to the code used for classes that do define default constructors.
- * Thus, this neat trick allows us to fix this special case without having to
- * make massive changes to typemaps and other parts of the SWIG code generator.
- *
- * Note: this code is not included when SWIG runs in C-mode, when classes
- * define default constructors, or when pointers and references are used.
- * SWIG tries to avoid doing this except in very special circumstances.
- *
- * Note: This solution suffers from making a large number of copies
- * of the underlying object.  However, this is needed in the interest of
- * safety and in order to cover all of the possible ways in which a value
- * might be assigned.  For example:
- *
- *       arg1 = *inarg1;       // Assignment from a pointer
- *       arg1 = Vector(1,2,3); // Assignment from a value  
- *
- * The class offers a strong guarantee of exception safety.
- * With regards to the implementation, the private SwigMovePointer nested class is 
- * a simple smart pointer with move semantics, much like std::auto_ptr.
- *
- * This wrapping technique was suggested by William Fulton and is henceforth
- * known as the "Fulton Transform" :-).
- */
-
-#ifdef __cplusplus
-%insert("runtime") %{
-#ifdef __cplusplus
-/* SwigValueWrapper is described in swig.swg */
-template<typename T> class SwigValueWrapper {
-  struct SwigMovePointer {
-    T *ptr;
-    SwigMovePointer(T *p) : ptr(p) { }
-    ~SwigMovePointer() { delete ptr; }
-    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
-  } pointer;
-  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
-  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
-public:
-  SwigValueWrapper() : pointer(0) { }
-  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
-  operator T&() const { return *pointer.ptr; }
-  T *operator&() { return pointer.ptr; }
-};%}
-
-/*
- * SwigValueInit() is a generic initialisation solution as the following approach:
- * 
- *       T c_result = T();
- * 
- * doesn't compile for all types for example:
- * 
- *       unsigned int c_result = unsigned int();
- */
-%insert("runtime") %{
-template <typename T> T SwigValueInit() {
-  return T();
-}
-#endif
-%}
-#endif
-
-/*  The swiglabels  */
-
-%insert("runtime") "swiglabels.swg"
-
-
diff --git a/share/swig/2.0.11/swigarch.i b/share/swig/2.0.11/swigarch.i
deleted file mode 100644
index f5aea46..0000000
--- a/share/swig/2.0.11/swigarch.i
+++ /dev/null
@@ -1,62 +0,0 @@
-/* -----------------------------------------------------------------------------
- * swigarch.i
- *
- * SWIG library file for 32bit/64bit code specialization and checking.
- *
- * Use only in extreme cases, when no arch. independent code can be
- * generated
- * 
- * To activate architecture specific code, use
- *
- *     swig -DSWIGWORDSIZE32
- *
- * or
- *
- *     swig -DSWIGWORDSIZE64
- *
- * Note that extra checking code will be added to the wrapped code,
- * which will prevent the compilation in a different architecture.
- *
- * If you don't specify the SWIGWORDSIZE (the default case), swig will
- * generate architecture independent and/or 32bits code, with no extra
- * checking code added.
- * ----------------------------------------------------------------------------- */
-
-#if !defined(SWIGWORDSIZE32) &&  !defined(SWIGWORDSIZE64)
-# if (__WORDSIZE == 32)
-#  define SWIGWORDSIZE32
-# endif
-#endif
-  
-#if !defined(SWIGWORDSIZE64) &&  !defined(SWIGWORDSIZE32) 
-# if defined(__x86_64) || defined(__x86_64__) || (__WORDSIZE == 64)
-#  define SWIGWORDSIZE64
-# endif
-#endif
-
-
-#ifdef SWIGWORDSIZE32
-%{
-#define SWIGWORDSIZE32
-#ifndef LONG_MAX
-#include <limits.h>
-#endif
-#if (__WORDSIZE == 64) || (LONG_MAX != INT_MAX)
-# error "SWIG wrapped code invalid in 64 bit architecture, regenarete code using -DSWIGWORDSIZE64"
-#endif
-%}
-#endif
-
-#ifdef SWIGWORDSIZE64
-%{
-#define SWIGWORDSIZE64
-#ifndef LONG_MAX
-#include <limits.h>
-#endif
-#if (__WORDSIZE == 32) || (LONG_MAX == INT_MAX)
-# error "SWIG wrapped code invalid in 32 bit architecture, regenarete code using -DSWIGWORDSIZE32"
-#endif
-%}
-#endif
-  
-
diff --git a/share/swig/2.0.11/swiginit.swg b/share/swig/2.0.11/swiginit.swg
deleted file mode 100644
index f321181..0000000
--- a/share/swig/2.0.11/swiginit.swg
+++ /dev/null
@@ -1,234 +0,0 @@
-/* -----------------------------------------------------------------------------
- * Type initialization:
- * This problem is tough by the requirement that no dynamic
- * memory is used. Also, since swig_type_info structures store pointers to
- * swig_cast_info structures and swig_cast_info structures store pointers back
- * to swig_type_info structures, we need some lookup code at initialization.
- * The idea is that swig generates all the structures that are needed.
- * The runtime then collects these partially filled structures.
- * The SWIG_InitializeModule function takes these initial arrays out of
- * swig_module, and does all the lookup, filling in the swig_module.types
- * array with the correct data and linking the correct swig_cast_info
- * structures together.
- *
- * The generated swig_type_info structures are assigned staticly to an initial
- * array. We just loop through that array, and handle each type individually.
- * First we lookup if this type has been already loaded, and if so, use the
- * loaded structure instead of the generated one. Then we have to fill in the
- * cast linked list. The cast data is initially stored in something like a
- * two-dimensional array. Each row corresponds to a type (there are the same
- * number of rows as there are in the swig_type_initial array). Each entry in
- * a column is one of the swig_cast_info structures for that type.
- * The cast_initial array is actually an array of arrays, because each row has
- * a variable number of columns. So to actually build the cast linked list,
- * we find the array of casts associated with the type, and loop through it
- * adding the casts to the list. The one last trick we need to do is making
- * sure the type pointer in the swig_cast_info struct is correct.
- *
- * First off, we lookup the cast->type name to see if it is already loaded.
- * There are three cases to handle:
- *  1) If the cast->type has already been loaded AND the type we are adding
- *     casting info to has not been loaded (it is in this module), THEN we
- *     replace the cast->type pointer with the type pointer that has already
- *     been loaded.
- *  2) If BOTH types (the one we are adding casting info to, and the
- *     cast->type) are loaded, THEN the cast info has already been loaded by
- *     the previous module so we just ignore it.
- *  3) Finally, if cast->type has not already been loaded, then we add that
- *     swig_cast_info to the linked list (because the cast->type) pointer will
- *     be correct.
- * ----------------------------------------------------------------------------- */
-
-#ifdef __cplusplus
-extern "C" {
-#if 0
-} /* c-mode */
-#endif
-#endif
-
-#if 0
-#define SWIGRUNTIME_DEBUG
-#endif
-
-
-SWIGRUNTIME void
-SWIG_InitializeModule(void *clientdata) {
-  size_t i;
-  swig_module_info *module_head, *iter;
-  int found, init;
-
-  /* check to see if the circular list has been setup, if not, set it up */
-  if (swig_module.next==0) {
-    /* Initialize the swig_module */
-    swig_module.type_initial = swig_type_initial;
-    swig_module.cast_initial = swig_cast_initial;
-    swig_module.next = &swig_module;
-    init = 1;
-  } else {
-    init = 0;
-  }
-
-  /* Try and load any already created modules */
-  module_head = SWIG_GetModule(clientdata);
-  if (!module_head) {
-    /* This is the first module loaded for this interpreter */
-    /* so set the swig module into the interpreter */
-    SWIG_SetModule(clientdata, &swig_module);
-    module_head = &swig_module;
-  } else {
-    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
-    found=0;
-    iter=module_head;
-    do {
-      if (iter==&swig_module) {
-        found=1;
-        break;
-      }
-      iter=iter->next;
-    } while (iter!= module_head);
-
-    /* if the is found in the list, then all is done and we may leave */
-    if (found) return;
-    /* otherwise we must add out module into the list */
-    swig_module.next = module_head->next;
-    module_head->next = &swig_module;
-  }
-
-  /* When multiple interpreters are used, a module could have already been initialized in
-     a different interpreter, but not yet have a pointer in this interpreter.
-     In this case, we do not want to continue adding types... everything should be
-     set up already */
-  if (init == 0) return;
-
-  /* Now work on filling in swig_module.types */
-#ifdef SWIGRUNTIME_DEBUG
-  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
-#endif
-  for (i = 0; i < swig_module.size; ++i) {
-    swig_type_info *type = 0;
-    swig_type_info *ret;
-    swig_cast_info *cast;
-
-#ifdef SWIGRUNTIME_DEBUG
-    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
-#endif
-
-    /* if there is another module already loaded */
-    if (swig_module.next != &swig_module) {
-      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
-    }
-    if (type) {
-      /* Overwrite clientdata field */
-#ifdef SWIGRUNTIME_DEBUG
-      printf("SWIG_InitializeModule: found type %s\n", type->name);
-#endif
-      if (swig_module.type_initial[i]->clientdata) {
-	type->clientdata = swig_module.type_initial[i]->clientdata;
-#ifdef SWIGRUNTIME_DEBUG
-      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
-#endif
-      }
-    } else {
-      type = swig_module.type_initial[i];
-    }
-
-    /* Insert casting types */
-    cast = swig_module.cast_initial[i];
-    while (cast->type) {
-
-      /* Don't need to add information already in the list */
-      ret = 0;
-#ifdef SWIGRUNTIME_DEBUG
-      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
-#endif
-      if (swig_module.next != &swig_module) {
-        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
-#ifdef SWIGRUNTIME_DEBUG
-	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
-#endif
-      }
-      if (ret) {
-	if (type == swig_module.type_initial[i]) {
-#ifdef SWIGRUNTIME_DEBUG
-	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
-#endif
-	  cast->type = ret;
-	  ret = 0;
-	} else {
-	  /* Check for casting already in the list */
-	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
-#ifdef SWIGRUNTIME_DEBUG
-	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
-#endif
-	  if (!ocast) ret = 0;
-	}
-      }
-
-      if (!ret) {
-#ifdef SWIGRUNTIME_DEBUG
-	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
-#endif
-        if (type->cast) {
-          type->cast->prev = cast;
-          cast->next = type->cast;
-        }
-        type->cast = cast;
-      }
-      cast++;
-    }
-    /* Set entry in modules->types array equal to the type */
-    swig_module.types[i] = type;
-  }
-  swig_module.types[i] = 0;
-
-#ifdef SWIGRUNTIME_DEBUG
-  printf("**** SWIG_InitializeModule: Cast List ******\n");
-  for (i = 0; i < swig_module.size; ++i) {
-    int j = 0;
-    swig_cast_info *cast = swig_module.cast_initial[i];
-    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
-    while (cast->type) {
-      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
-      cast++;
-      ++j;
-    }
-  printf("---- Total casts: %d\n",j);
-  }
-  printf("**** SWIG_InitializeModule: Cast List ******\n");
-#endif
-}
-
-/* This function will propagate the clientdata field of type to
-* any new swig_type_info structures that have been added into the list
-* of equivalent types.  It is like calling
-* SWIG_TypeClientData(type, clientdata) a second time.
-*/
-SWIGRUNTIME void
-SWIG_PropagateClientData(void) {
-  size_t i;
-  swig_cast_info *equiv;
-  static int init_run = 0;
-
-  if (init_run) return;
-  init_run = 1;
-
-  for (i = 0; i < swig_module.size; i++) {
-    if (swig_module.types[i]->clientdata) {
-      equiv = swig_module.types[i]->cast;
-      while (equiv) {
-        if (!equiv->converter) {
-          if (equiv->type && !equiv->type->clientdata)
-            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
-        }
-        equiv = equiv->next;
-      }
-    }
-  }
-}
-
-#ifdef __cplusplus
-#if 0
-{ /* c-mode */
-#endif
-}
-#endif
diff --git a/share/swig/2.0.11/swiglabels.swg b/share/swig/2.0.11/swiglabels.swg
deleted file mode 100644
index d428ac3..0000000
--- a/share/swig/2.0.11/swiglabels.swg
+++ /dev/null
@@ -1,108 +0,0 @@
-/* -----------------------------------------------------------------------------
- *  This section contains generic SWIG labels for method/variable
- *  declarations/attributes, and other compiler dependent labels.
- * ----------------------------------------------------------------------------- */
-
-/* template workaround for compilers that cannot correctly implement the C++ standard */
-#ifndef SWIGTEMPLATEDISAMBIGUATOR
-# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
-#  define SWIGTEMPLATEDISAMBIGUATOR template
-# elif defined(__HP_aCC)
-/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
-/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
-#  define SWIGTEMPLATEDISAMBIGUATOR template
-# else
-#  define SWIGTEMPLATEDISAMBIGUATOR
-# endif
-#endif
-
-/* inline attribute */
-#ifndef SWIGINLINE
-# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
-#   define SWIGINLINE inline
-# else
-#   define SWIGINLINE
-# endif
-#endif
-
-/* attribute recognised by some compilers to avoid 'unused' warnings */
-#ifndef SWIGUNUSED
-# if defined(__GNUC__)
-#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
-#     define SWIGUNUSED __attribute__ ((__unused__))
-#   else
-#     define SWIGUNUSED
-#   endif
-# elif defined(__ICC)
-#   define SWIGUNUSED __attribute__ ((__unused__))
-# else
-#   define SWIGUNUSED
-# endif
-#endif
-
-#ifndef SWIG_MSC_UNSUPPRESS_4505
-# if defined(_MSC_VER)
-#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
-# endif
-#endif
-
-#ifndef SWIGUNUSEDPARM
-# ifdef __cplusplus
-#   define SWIGUNUSEDPARM(p)
-# else
-#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
-# endif
-#endif
-
-/* internal SWIG method */
-#ifndef SWIGINTERN
-# define SWIGINTERN static SWIGUNUSED
-#endif
-
-/* internal inline SWIG method */
-#ifndef SWIGINTERNINLINE
-# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
-#endif
-
-/* exporting methods */
-#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
-#  ifndef GCC_HASCLASSVISIBILITY
-#    define GCC_HASCLASSVISIBILITY
-#  endif
-#endif
-
-#ifndef SWIGEXPORT
-# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
-#   if defined(STATIC_LINKED)
-#     define SWIGEXPORT
-#   else
-#     define SWIGEXPORT __declspec(dllexport)
-#   endif
-# else
-#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
-#     define SWIGEXPORT __attribute__ ((visibility("default")))
-#   else
-#     define SWIGEXPORT
-#   endif
-# endif
-#endif
-
-/* calling conventions for Windows */
-#ifndef SWIGSTDCALL
-# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
-#   define SWIGSTDCALL __stdcall
-# else
-#   define SWIGSTDCALL
-# endif
-#endif
-
-/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
-#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
-# define _CRT_SECURE_NO_DEPRECATE
-#endif
-
-/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
-#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
-# define _SCL_SECURE_NO_DEPRECATE
-#endif
-
diff --git a/share/swig/2.0.11/swigrun.swg b/share/swig/2.0.11/swigrun.swg
deleted file mode 100644
index 7066e67..0000000
--- a/share/swig/2.0.11/swigrun.swg
+++ /dev/null
@@ -1,572 +0,0 @@
-/* -----------------------------------------------------------------------------
- * swigrun.swg
- *
- * This file contains generic C API SWIG runtime support for pointer
- * type checking.
- * ----------------------------------------------------------------------------- */
-
-/* This should only be incremented when either the layout of swig_type_info changes,
-   or for whatever reason, the runtime changes incompatibly */
-#define SWIG_RUNTIME_VERSION "4"
-
-/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
-#ifdef SWIG_TYPE_TABLE
-# define SWIG_QUOTE_STRING(x) #x
-# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
-# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
-#else
-# define SWIG_TYPE_TABLE_NAME
-#endif
-
-/*
-  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
-  creating a static or dynamic library from the SWIG runtime code.
-  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
-
-  But only do this if strictly necessary, ie, if you have problems
-  with your compiler or suchlike.
-*/
-
-#ifndef SWIGRUNTIME
-# define SWIGRUNTIME SWIGINTERN
-#endif
-
-#ifndef SWIGRUNTIMEINLINE
-# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
-#endif
-
-/*  Generic buffer size */
-#ifndef SWIG_BUFFER_SIZE
-# define SWIG_BUFFER_SIZE 1024
-#endif
-
-/* Flags for pointer conversions */
-#define SWIG_POINTER_DISOWN        0x1
-#define SWIG_CAST_NEW_MEMORY       0x2
-
-/* Flags for new pointer objects */
-#define SWIG_POINTER_OWN           0x1
-
-
-/*
-   Flags/methods for returning states.
-
-   The SWIG conversion methods, as ConvertPtr, return an integer
-   that tells if the conversion was successful or not. And if not,
-   an error code can be returned (see swigerrors.swg for the codes).
-
-   Use the following macros/flags to set or process the returning
-   states.
-
-   In old versions of SWIG, code such as the following was usually written:
-
-     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
-       // success code
-     } else {
-       //fail code
-     }
-
-   Now you can be more explicit:
-
-    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
-    if (SWIG_IsOK(res)) {
-      // success code
-    } else {
-      // fail code
-    }
-
-   which is the same really, but now you can also do
-
-    Type *ptr;
-    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
-    if (SWIG_IsOK(res)) {
-      // success code
-      if (SWIG_IsNewObj(res) {
-        ...
-	delete *ptr;
-      } else {
-        ...
-      }
-    } else {
-      // fail code
-    }
-
-   I.e., now SWIG_ConvertPtr can return new objects and you can
-   identify the case and take care of the deallocation. Of course that
-   also requires SWIG_ConvertPtr to return new result values, such as
-
-      int SWIG_ConvertPtr(obj, ptr,...) {
-        if (<obj is ok>) {
-          if (<need new object>) {
-            *ptr = <ptr to new allocated object>;
-            return SWIG_NEWOBJ;
-          } else {
-            *ptr = <ptr to old object>;
-            return SWIG_OLDOBJ;
-          }
-        } else {
-          return SWIG_BADOBJ;
-        }
-      }
-
-   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
-   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
-   SWIG errors code.
-
-   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
-   allows to return the 'cast rank', for example, if you have this
-
-       int food(double)
-       int fooi(int);
-
-   and you call
-
-      food(1)   // cast rank '1'  (1 -> 1.0)
-      fooi(1)   // cast rank '0'
-
-   just use the SWIG_AddCast()/SWIG_CheckState()
-*/
-
-#define SWIG_OK                    (0)
-#define SWIG_ERROR                 (-1)
-#define SWIG_IsOK(r)               (r >= 0)
-#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
-
-/* The CastRankLimit says how many bits are used for the cast rank */
-#define SWIG_CASTRANKLIMIT         (1 << 8)
-/* The NewMask denotes the object was created (using new/malloc) */
-#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
-/* The TmpMask is for in/out typemaps that use temporal objects */
-#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
-/* Simple returning values */
-#define SWIG_BADOBJ                (SWIG_ERROR)
-#define SWIG_OLDOBJ                (SWIG_OK)
-#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
-#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
-/* Check, add and del mask methods */
-#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
-#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
-#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
-#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
-#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
-#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
-
-/* Cast-Rank Mode */
-#if defined(SWIG_CASTRANK_MODE)
-#  ifndef SWIG_TypeRank
-#    define SWIG_TypeRank             unsigned long
-#  endif
-#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
-#    define SWIG_MAXCASTRANK          (2)
-#  endif
-#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
-#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
-SWIGINTERNINLINE int SWIG_AddCast(int r) {
-  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
-}
-SWIGINTERNINLINE int SWIG_CheckState(int r) {
-  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
-}
-#else /* no cast-rank mode */
-#  define SWIG_AddCast(r) (r)
-#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
-#endif
-
-
-#include <string.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef void *(*swig_converter_func)(void *, int *);
-typedef struct swig_type_info *(*swig_dycast_func)(void **);
-
-/* Structure to store information on one type */
-typedef struct swig_type_info {
-  const char             *name;			/* mangled name of this type */
-  const char             *str;			/* human readable name of this type */
-  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
-  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
-  void                   *clientdata;		/* language specific type data */
-  int                    owndata;		/* flag if the structure owns the clientdata */
-} swig_type_info;
-
-/* Structure to store a type and conversion function used for casting */
-typedef struct swig_cast_info {
-  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
-  swig_converter_func     converter;		/* function to cast the void pointers */
-  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
-  struct swig_cast_info  *prev;			/* pointer to the previous cast */
-} swig_cast_info;
-
-/* Structure used to store module information
- * Each module generates one structure like this, and the runtime collects
- * all of these structures and stores them in a circularly linked list.*/
-typedef struct swig_module_info {
-  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
-  size_t                 size;		        /* Number of types in this module */
-  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
-  swig_type_info         **type_initial;	/* Array of initially generated type structures */
-  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
-  void                    *clientdata;		/* Language specific module data */
-} swig_module_info;
-
-/*
-  Compare two type names skipping the space characters, therefore
-  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
-
-  Return 0 when the two name types are equivalent, as in
-  strncmp, but skipping ' '.
-*/
-SWIGRUNTIME int
-SWIG_TypeNameComp(const char *f1, const char *l1,
-		  const char *f2, const char *l2) {
-  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
-    while ((*f1 == ' ') && (f1 != l1)) ++f1;
-    while ((*f2 == ' ') && (f2 != l2)) ++f2;
-    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
-  }
-  return (int)((l1 - f1) - (l2 - f2));
-}
-
-/*
-  Check type equivalence in a name list like <name1>|<name2>|...
-  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
-*/
-SWIGRUNTIME int
-SWIG_TypeCmp(const char *nb, const char *tb) {
-  int equiv = 1;
-  const char* te = tb + strlen(tb);
-  const char* ne = nb;
-  while (equiv != 0 && *ne) {
-    for (nb = ne; *ne; ++ne) {
-      if (*ne == '|') break;
-    }
-    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
-    if (*ne) ++ne;
-  }
-  return equiv;
-}
-
-/*
-  Check type equivalence in a name list like <name1>|<name2>|...
-  Return 0 if not equal, 1 if equal
-*/
-SWIGRUNTIME int
-SWIG_TypeEquiv(const char *nb, const char *tb) {
-  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
-}
-
-/*
-  Check the typename
-*/
-SWIGRUNTIME swig_cast_info *
-SWIG_TypeCheck(const char *c, swig_type_info *ty) {
-  if (ty) {
-    swig_cast_info *iter = ty->cast;
-    while (iter) {
-      if (strcmp(iter->type->name, c) == 0) {
-        if (iter == ty->cast)
-          return iter;
-        /* Move iter to the top of the linked list */
-        iter->prev->next = iter->next;
-        if (iter->next)
-          iter->next->prev = iter->prev;
-        iter->next = ty->cast;
-        iter->prev = 0;
-        if (ty->cast) ty->cast->prev = iter;
-        ty->cast = iter;
-        return iter;
-      }
-      iter = iter->next;
-    }
-  }
-  return 0;
-}
-
-/*
-  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
-*/
-SWIGRUNTIME swig_cast_info *
-SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
-  if (ty) {
-    swig_cast_info *iter = ty->cast;
-    while (iter) {
-      if (iter->type == from) {
-        if (iter == ty->cast)
-          return iter;
-        /* Move iter to the top of the linked list */
-        iter->prev->next = iter->next;
-        if (iter->next)
-          iter->next->prev = iter->prev;
-        iter->next = ty->cast;
-        iter->prev = 0;
-        if (ty->cast) ty->cast->prev = iter;
-        ty->cast = iter;
-        return iter;
-      }
-      iter = iter->next;
-    }
-  }
-  return 0;
-}
-
-/*
-  Cast a pointer up an inheritance hierarchy
-*/
-SWIGRUNTIMEINLINE void *
-SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
-  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
-}
-
-/*
-   Dynamic pointer casting. Down an inheritance hierarchy
-*/
-SWIGRUNTIME swig_type_info *
-SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
-  swig_type_info *lastty = ty;
-  if (!ty || !ty->dcast) return ty;
-  while (ty && (ty->dcast)) {
-    ty = (*ty->dcast)(ptr);
-    if (ty) lastty = ty;
-  }
-  return lastty;
-}
-
-/*
-  Return the name associated with this type
-*/
-SWIGRUNTIMEINLINE const char *
-SWIG_TypeName(const swig_type_info *ty) {
-  return ty->name;
-}
-
-/*
-  Return the pretty name associated with this type,
-  that is an unmangled type name in a form presentable to the user.
-*/
-SWIGRUNTIME const char *
-SWIG_TypePrettyName(const swig_type_info *type) {
-  /* The "str" field contains the equivalent pretty names of the
-     type, separated by vertical-bar characters.  We choose
-     to print the last name, as it is often (?) the most
-     specific. */
-  if (!type) return NULL;
-  if (type->str != NULL) {
-    const char *last_name = type->str;
-    const char *s;
-    for (s = type->str; *s; s++)
-      if (*s == '|') last_name = s+1;
-    return last_name;
-  }
-  else
-    return type->name;
-}
-
-/*
-   Set the clientdata field for a type
-*/
-SWIGRUNTIME void
-SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
-  swig_cast_info *cast = ti->cast;
-  /* if (ti->clientdata == clientdata) return; */
-  ti->clientdata = clientdata;
-
-  while (cast) {
-    if (!cast->converter) {
-      swig_type_info *tc = cast->type;
-      if (!tc->clientdata) {
-	SWIG_TypeClientData(tc, clientdata);
-      }
-    }
-    cast = cast->next;
-  }
-}
-SWIGRUNTIME void
-SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
-  SWIG_TypeClientData(ti, clientdata);
-  ti->owndata = 1;
-}
-
-/*
-  Search for a swig_type_info structure only by mangled name
-  Search is a O(log #types)
-
-  We start searching at module start, and finish searching when start == end.
-  Note: if start == end at the beginning of the function, we go all the way around
-  the circular list.
-*/
-SWIGRUNTIME swig_type_info *
-SWIG_MangledTypeQueryModule(swig_module_info *start,
-                            swig_module_info *end,
-		            const char *name) {
-  swig_module_info *iter = start;
-  do {
-    if (iter->size) {
-      register size_t l = 0;
-      register size_t r = iter->size - 1;
-      do {
-	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
-	register size_t i = (l + r) >> 1;
-	const char *iname = iter->types[i]->name;
-	if (iname) {
-	  register int compare = strcmp(name, iname);
-	  if (compare == 0) {
-	    return iter->types[i];
-	  } else if (compare < 0) {
-	    if (i) {
-	      r = i - 1;
-	    } else {
-	      break;
-	    }
-	  } else if (compare > 0) {
-	    l = i + 1;
-	  }
-	} else {
-	  break; /* should never happen */
-	}
-      } while (l <= r);
-    }
-    iter = iter->next;
-  } while (iter != end);
-  return 0;
-}
-
-/*
-  Search for a swig_type_info structure for either a mangled name or a human readable name.
-  It first searches the mangled names of the types, which is a O(log #types)
-  If a type is not found it then searches the human readable names, which is O(#types).
-
-  We start searching at module start, and finish searching when start == end.
-  Note: if start == end at the beginning of the function, we go all the way around
-  the circular list.
-*/
-SWIGRUNTIME swig_type_info *
-SWIG_TypeQueryModule(swig_module_info *start,
-                     swig_module_info *end,
-		     const char *name) {
-  /* STEP 1: Search the name field using binary search */
-  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
-  if (ret) {
-    return ret;
-  } else {
-    /* STEP 2: If the type hasn't been found, do a complete search
-       of the str field (the human readable name) */
-    swig_module_info *iter = start;
-    do {
-      register size_t i = 0;
-      for (; i < iter->size; ++i) {
-	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
-	  return iter->types[i];
-      }
-      iter = iter->next;
-    } while (iter != end);
-  }
-
-  /* neither found a match */
-  return 0;
-}
-
-/*
-   Pack binary data into a string
-*/
-SWIGRUNTIME 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;
-}
-
-/*
-   Unpack binary data from a string
-*/
-SWIGRUNTIME 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;
-}
-
-/*
-   Pack 'void *' into a string buffer.
-*/
-SWIGRUNTIME char *
-SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
-  char *r = buff;
-  if ((2*sizeof(void *) + 2) > bsz) return 0;
-  *(r++) = '_';
-  r = SWIG_PackData(r,&ptr,sizeof(void *));
-  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
-  strcpy(r,name);
-  return buff;
-}
-
-SWIGRUNTIME const char *
-SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
-  if (*c != '_') {
-    if (strcmp(c,"NULL") == 0) {
-      *ptr = (void *) 0;
-      return name;
-    } else {
-      return 0;
-    }
-  }
-  return SWIG_UnpackData(++c,ptr,sizeof(void *));
-}
-
-SWIGRUNTIME char *
-SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
-  char *r = buff;
-  size_t lname = (name ? strlen(name) : 0);
-  if ((2*sz + 2 + lname) > bsz) return 0;
-  *(r++) = '_';
-  r = SWIG_PackData(r,ptr,sz);
-  if (lname) {
-    strncpy(r,name,lname+1);
-  } else {
-    *r = 0;
-  }
-  return buff;
-}
-
-SWIGRUNTIME const char *
-SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
-  if (*c != '_') {
-    if (strcmp(c,"NULL") == 0) {
-      memset(ptr,0,sz);
-      return name;
-    } else {
-      return 0;
-    }
-  }
-  return SWIG_UnpackData(++c,ptr,sz);
-}
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/share/swig/2.0.11/swigwarn.swg b/share/swig/2.0.11/swigwarn.swg
deleted file mode 100644
index 9bc8638..0000000
--- a/share/swig/2.0.11/swigwarn.swg
+++ /dev/null
@@ -1,271 +0,0 @@
-/* SWIG warning codes */
-
-
-%define SWIGWARN_NONE                     0 %enddef
-
-/* -- Deprecated features -- */
-
-%define SWIGWARN_DEPRECATED_EXTERN        101 %enddef
-%define SWIGWARN_DEPRECATED_VAL           102 %enddef
-%define SWIGWARN_DEPRECATED_OUT           103 %enddef
-%define SWIGWARN_DEPRECATED_DISABLEDOC    104 %enddef
-%define SWIGWARN_DEPRECATED_ENABLEDOC     105 %enddef
-%define SWIGWARN_DEPRECATED_DOCONLY       106 %enddef
-%define SWIGWARN_DEPRECATED_STYLE         107 %enddef
-%define SWIGWARN_DEPRECATED_LOCALSTYLE    108 %enddef
-%define SWIGWARN_DEPRECATED_TITLE         109 %enddef
-%define SWIGWARN_DEPRECATED_SECTION       110 %enddef
-%define SWIGWARN_DEPRECATED_SUBSECTION    111 %enddef
-%define SWIGWARN_DEPRECATED_SUBSUBSECTION 112 %enddef
-%define SWIGWARN_DEPRECATED_ADDMETHODS    113 %enddef
-%define SWIGWARN_DEPRECATED_READONLY      114 %enddef
-%define SWIGWARN_DEPRECATED_READWRITE     115 %enddef
-%define SWIGWARN_DEPRECATED_EXCEPT        116 %enddef
-%define SWIGWARN_DEPRECATED_NEW           117 %enddef
-%define SWIGWARN_DEPRECATED_EXCEPT_TM     118 %enddef
-%define SWIGWARN_DEPRECATED_IGNORE_TM     119 %enddef
-%define SWIGWARN_DEPRECATED_OPTC          120 %enddef
-%define SWIGWARN_DEPRECATED_NAME          121 %enddef
-%define SWIGWARN_DEPRECATED_NOEXTERN      122 %enddef
-%define SWIGWARN_DEPRECATED_NODEFAULT     123 %enddef
-%define SWIGWARN_DEPRECATED_TYPEMAP_LANG  124 %enddef
-%define SWIGWARN_DEPRECATED_INPUT_FILE    125 %enddef
-
-/* -- Preprocessor -- */
-
-%define SWIGWARN_PP_MISSING_FILE          201 %enddef
-%define SWIGWARN_PP_EVALUATION            202 %enddef
-%define SWIGWARN_PP_INCLUDEALL_IMPORTALL  203 %enddef
-%define SWIGWARN_PP_CPP_WARNING           204 %enddef
-%define SWIGWARN_PP_CPP_ERROR             205 %enddef
-%define SWIGWARN_PP_UNEXPECTED_TOKENS     206 %enddef
-
-/* -- C/C++ Parser -- */
-
-%define SWIGWARN_PARSE_CLASS_KEYWORD      301 %enddef
-%define SWIGWARN_PARSE_REDEFINED          302 %enddef
-%define SWIGWARN_PARSE_EXTEND_UNDEF       303 %enddef
-%define SWIGWARN_PARSE_UNSUPPORTED_VALUE  304 %enddef
-%define SWIGWARN_PARSE_BAD_VALUE          305 %enddef
-%define SWIGWARN_PARSE_PRIVATE            306 %enddef
-%define SWIGWARN_PARSE_BAD_DEFAULT        307 %enddef
-%define SWIGWARN_PARSE_NAMESPACE_ALIAS    308 %enddef
-%define SWIGWARN_PARSE_PRIVATE_INHERIT    309 %enddef
-%define SWIGWARN_PARSE_TEMPLATE_REPEAT    310 %enddef
-%define SWIGWARN_PARSE_TEMPLATE_PARTIAL   311 %enddef
-%define SWIGWARN_PARSE_UNNAMED_NESTED_CLASS 312 %enddef
-%define SWIGWARN_PARSE_UNDEFINED_EXTERN   313 %enddef
-%define SWIGWARN_PARSE_KEYWORD            314 %enddef
-%define SWIGWARN_PARSE_USING_UNDEF        315 %enddef
-%define SWIGWARN_PARSE_MODULE_REPEAT      316 %enddef
-%define SWIGWARN_PARSE_TEMPLATE_SP_UNDEF  317 %enddef
-%define SWIGWARN_PARSE_TEMPLATE_AMBIG     318 %enddef
-%define SWIGWARN_PARSE_NO_ACCESS          319 %enddef
-%define SWIGWARN_PARSE_EXPLICIT_TEMPLATE  320 %enddef
-%define SWIGWARN_PARSE_BUILTIN_NAME       321 %enddef
-%define SWIGWARN_PARSE_REDUNDANT          322 %enddef
-%define SWIGWARN_PARSE_REC_INHERITANCE    323 %enddef
-%define SWIGWARN_PARSE_NESTED_TEMPLATE    324 %enddef
-%define SWIGWARN_PARSE_NAMED_NESTED_CLASS 325 %enddef
-%define SWIGWARN_PARSE_EXTEND_NAME        326 %enddef
-
-%define SWIGWARN_IGNORE_OPERATOR_NEW        350 %enddef	/* new */
-%define SWIGWARN_IGNORE_OPERATOR_DELETE     351 %enddef	/* delete */
-%define SWIGWARN_IGNORE_OPERATOR_PLUS       352 %enddef	/* + */
-%define SWIGWARN_IGNORE_OPERATOR_MINUS      353 %enddef	/* - */
-%define SWIGWARN_IGNORE_OPERATOR_MUL        354 %enddef	/* * */
-%define SWIGWARN_IGNORE_OPERATOR_DIV        355 %enddef	/* / */
-%define SWIGWARN_IGNORE_OPERATOR_MOD        356 %enddef	/* % */
-%define SWIGWARN_IGNORE_OPERATOR_XOR        357 %enddef	/* ^ */
-%define SWIGWARN_IGNORE_OPERATOR_AND        358 %enddef	/* & */
-%define SWIGWARN_IGNORE_OPERATOR_OR         359 %enddef	/* | */
-%define SWIGWARN_IGNORE_OPERATOR_NOT        360 %enddef	/* ~ */
-%define SWIGWARN_IGNORE_OPERATOR_LNOT       361 %enddef	/* ! */
-%define SWIGWARN_IGNORE_OPERATOR_EQ         362 %enddef	/* = */
-%define SWIGWARN_IGNORE_OPERATOR_LT         363 %enddef	/* < */
-%define SWIGWARN_IGNORE_OPERATOR_GT         364 %enddef	/* > */
-%define SWIGWARN_IGNORE_OPERATOR_PLUSEQ     365 %enddef	/* += */
-%define SWIGWARN_IGNORE_OPERATOR_MINUSEQ    366 %enddef	/* -= */
-%define SWIGWARN_IGNORE_OPERATOR_MULEQ      367 %enddef	/* *= */
-%define SWIGWARN_IGNORE_OPERATOR_DIVEQ      368 %enddef	/* /= */
-%define SWIGWARN_IGNORE_OPERATOR_MODEQ      369 %enddef	/* %= */
-%define SWIGWARN_IGNORE_OPERATOR_XOREQ      370 %enddef	/* ^= */
-%define SWIGWARN_IGNORE_OPERATOR_ANDEQ      371 %enddef	/* &= */
-%define SWIGWARN_IGNORE_OPERATOR_OREQ       372 %enddef	/* |= */
-%define SWIGWARN_IGNORE_OPERATOR_LSHIFT     373 %enddef	/* << */
-%define SWIGWARN_IGNORE_OPERATOR_RSHIFT     374 %enddef	/* >> */
-%define SWIGWARN_IGNORE_OPERATOR_LSHIFTEQ   375 %enddef	/* <<= */
-%define SWIGWARN_IGNORE_OPERATOR_RSHIFTEQ   376 %enddef	/* >>= */
-%define SWIGWARN_IGNORE_OPERATOR_EQUALTO    377 %enddef	/* == */
-%define SWIGWARN_IGNORE_OPERATOR_NOTEQUAL   378 %enddef	/* != */
-%define SWIGWARN_IGNORE_OPERATOR_LTEQUAL    379 %enddef	/* <= */
-%define SWIGWARN_IGNORE_OPERATOR_GTEQUAL    380 %enddef	/* >= */
-%define SWIGWARN_IGNORE_OPERATOR_LAND       381 %enddef	/* && */
-%define SWIGWARN_IGNORE_OPERATOR_LOR        382 %enddef	/* || */
-%define SWIGWARN_IGNORE_OPERATOR_PLUSPLUS   383 %enddef	/* ++ */
-%define SWIGWARN_IGNORE_OPERATOR_MINUSMINUS 384 %enddef	/* -- */
-%define SWIGWARN_IGNORE_OPERATOR_COMMA      385 %enddef	/* , */
-%define SWIGWARN_IGNORE_OPERATOR_ARROWSTAR  386 %enddef	/* ->* */
-%define SWIGWARN_IGNORE_OPERATOR_ARROW      387 %enddef	/* -> */
-%define SWIGWARN_IGNORE_OPERATOR_CALL       388 %enddef	/* () */
-%define SWIGWARN_IGNORE_OPERATOR_INDEX      389 %enddef	/* [] */
-%define SWIGWARN_IGNORE_OPERATOR_UPLUS      390 %enddef	/* + */
-%define SWIGWARN_IGNORE_OPERATOR_UMINUS     391 %enddef	/* - */
-%define SWIGWARN_IGNORE_OPERATOR_UMUL       392 %enddef	/* * */
-%define SWIGWARN_IGNORE_OPERATOR_UAND       393 %enddef	/* & */
-%define SWIGWARN_IGNORE_OPERATOR_NEWARR     394 %enddef	/* new [] */
-%define SWIGWARN_IGNORE_OPERATOR_DELARR     395 %enddef	/* delete [] */
-%define SWIGWARN_IGNORE_OPERATOR_REF        396 %enddef	/* operator *() */
-
-/* 394-399 are reserved */
-
-/* -- Type system and typemaps -- */
-
-%define SWIGWARN_TYPE_UNDEFINED_CLASS     401 %enddef
-%define SWIGWARN_TYPE_INCOMPLETE          402 %enddef
-%define SWIGWARN_TYPE_ABSTRACT            403 %enddef
-%define SWIGWARN_TYPE_REDEFINED           404 %enddef
-
-%define SWIGWARN_TYPEMAP_SOURCETARGET     450 %enddef
-%define SWIGWARN_TYPEMAP_CHARLEAK         451 %enddef
-%define SWIGWARN_TYPEMAP_SWIGTYPE         452 %enddef
-%define SWIGWARN_TYPEMAP_APPLY_UNDEF      453 %enddef
-%define SWIGWARN_TYPEMAP_SWIGTYPELEAK     454 %enddef
-
-%define SWIGWARN_TYPEMAP_IN_UNDEF         460 %enddef
-%define SWIGWARN_TYPEMAP_OUT_UNDEF        461 %enddef
-%define SWIGWARN_TYPEMAP_VARIN_UNDEF      462 %enddef
-%define SWIGWARN_TYPEMAP_VAROUT_UNDEF     463 %enddef
-%define SWIGWARN_TYPEMAP_CONST_UNDEF      464 %enddef
-%define SWIGWARN_TYPEMAP_UNDEF            465 %enddef
-%define SWIGWARN_TYPEMAP_VAR_UNDEF        466 %enddef
-%define SWIGWARN_TYPEMAP_TYPECHECK        467 %enddef
-%define SWIGWARN_TYPEMAP_THROW            468 %enddef
-%define SWIGWARN_TYPEMAP_DIRECTORIN_UNDEF  469 %enddef
-%define SWIGWARN_TYPEMAP_THREAD_UNSAFE     470 %enddef	/* mostly used in directorout typemaps */
-%define SWIGWARN_TYPEMAP_DIRECTOROUT_UNDEF 471 %enddef
-%define SWIGWARN_TYPEMAP_TYPECHECK_UNDEF   472 %enddef
-%define SWIGWARN_TYPEMAP_DIRECTOROUT_PTR   473 %enddef
-%define SWIGWARN_TYPEMAP_OUT_OPTIMAL_IGNORED  474 %enddef
-%define SWIGWARN_TYPEMAP_OUT_OPTIMAL_MULTIPLE 475 %enddef
-
-/* -- Fragments -- */
-%define SWIGWARN_FRAGMENT_NOT_FOUND       490 %enddef
-
-/* -- General code generation -- */
-
-%define SWIGWARN_LANG_OVERLOAD_DECL       501 %enddef
-%define SWIGWARN_LANG_OVERLOAD_CONSTRUCT  502 %enddef
-%define SWIGWARN_LANG_IDENTIFIER          503 %enddef
-%define SWIGWARN_LANG_RETURN_TYPE         504 %enddef
-%define SWIGWARN_LANG_VARARGS             505 %enddef
-%define SWIGWARN_LANG_VARARGS_KEYWORD     506 %enddef
-%define SWIGWARN_LANG_NATIVE_UNIMPL       507 %enddef
-%define SWIGWARN_LANG_DEREF_SHADOW        508 %enddef
-%define SWIGWARN_LANG_OVERLOAD_SHADOW     509 %enddef
-%define SWIGWARN_LANG_FRIEND_IGNORE       510 %enddef
-%define SWIGWARN_LANG_OVERLOAD_KEYWORD    511 %enddef
-%define SWIGWARN_LANG_OVERLOAD_CONST      512 %enddef
-%define SWIGWARN_LANG_CLASS_UNNAMED       513 %enddef
-%define SWIGWARN_LANG_DIRECTOR_VDESTRUCT  514 %enddef
-%define SWIGWARN_LANG_DISCARD_CONST       515 %enddef
-%define SWIGWARN_LANG_OVERLOAD_IGNORED    516 %enddef
-%define SWIGWARN_LANG_DIRECTOR_ABSTRACT   517 %enddef
-%define SWIGWARN_LANG_PORTABILITY_FILENAME 518 %enddef
-%define SWIGWARN_LANG_TEMPLATE_METHOD_IGNORE 519 %enddef
-%define SWIGWARN_LANG_SMARTPTR_MISSING    520 %enddef
-%define SWIGWARN_LANG_ILLEGAL_DESTRUCTOR  521 %enddef
-%define SWIGWARN_LANG_EXTEND_CONSTRUCTOR  522 %enddef
-%define SWIGWARN_LANG_EXTEND_DESTRUCTOR   523 %enddef
-
-/* -- Reserved (600-799) -- */
-
-/* -- Language module specific warnings (700 - 899) -- */
-
-
-%define SWIGWARN_D_TYPEMAP_CTYPE_UNDEF           700 %enddef
-%define SWIGWARN_D_TYPEMAP_IMTYPE_UNDEF           701 %enddef
-%define SWIGWARN_D_TYPEMAP_DTYPE_UNDEF           702 %enddef
-%define SWIGWARN_D_MULTIPLE_INHERITANCE           703 %enddef
-%define SWIGWARN_D_TYPEMAP_CLASSMOD_UNDEF         704 %enddef
-%define SWIGWARN_D_TYPEMAP_DBODY_UNDEF            705 %enddef
-%define SWIGWARN_D_TYPEMAP_DOUT_UNDEF             706 %enddef
-%define SWIGWARN_D_TYPEMAP_DIN_UNDEF              707 %enddef
-%define SWIGWARN_D_TYPEMAP_DDIRECTORIN_UNDEF      708 %enddef
-%define SWIGWARN_D_TYPEMAP_DCONSTRUCTOR_UNDEF     709 %enddef
-%define SWIGWARN_D_EXCODE_MISSING                 710 %enddef
-%define SWIGWARN_D_CANTHROW_MISSING               711 %enddef
-%define SWIGWARN_D_NO_DIRECTORCONNECT_ATTR        712 %enddef
-%define SWIGWARN_D_NAME_COLLISION                 713 %enddef
-
-/* please leave 700-719 free for D */
-
-%define SWIGWARN_RUBY_WRONG_NAME                  801 %enddef
-%define SWIGWARN_RUBY_MULTIPLE_INHERITANCE        802 %enddef
-
-/* please leave 800-809 free for Ruby */
-
-%define SWIGWARN_JAVA_TYPEMAP_JNI_UNDEF           810 %enddef
-%define SWIGWARN_JAVA_TYPEMAP_JTYPE_UNDEF         811 %enddef
-%define SWIGWARN_JAVA_TYPEMAP_JSTYPE_UNDEF        812 %enddef
-%define SWIGWARN_JAVA_MULTIPLE_INHERITANCE        813 %enddef
-%define SWIGWARN_JAVA_TYPEMAP_GETCPTR_UNDEF       814 %enddef
-%define SWIGWARN_JAVA_TYPEMAP_CLASSMOD_UNDEF      815 %enddef
-%define SWIGWARN_JAVA_TYPEMAP_JAVABODY_UNDEF      816 %enddef
-%define SWIGWARN_JAVA_TYPEMAP_JAVAOUT_UNDEF       817 %enddef
-%define SWIGWARN_JAVA_TYPEMAP_JAVAIN_UNDEF        818 %enddef
-%define SWIGWARN_JAVA_TYPEMAP_JAVADIRECTORIN_UNDEF    819 %enddef
-%define SWIGWARN_JAVA_TYPEMAP_JAVADIRECTOROUT_UNDEF   820 %enddef
-%define SWIGWARN_JAVA_COVARIANT_RET               822 %enddef
-%define SWIGWARN_JAVA_TYPEMAP_JAVACONSTRUCT_UNDEF 823 %enddef
-%define SWIGWARN_JAVA_TYPEMAP_DIRECTORIN_NODESC   824 %enddef
-%define SWIGWARN_JAVA_NO_DIRECTORCONNECT_ATTR     825 %enddef
-%define SWIGWARN_JAVA_NSPACE_WITHOUT_PACKAGE      826 %enddef
-
-/* please leave 810-829 free for Java */
-
-%define SWIGWARN_CSHARP_TYPEMAP_CTYPE_UNDEF       830 %enddef
-%define SWIGWARN_CSHARP_TYPEMAP_CSTYPE_UNDEF      831 %enddef
-%define SWIGWARN_CSHARP_TYPEMAP_CSWTYPE_UNDEF     832 %enddef
-%define SWIGWARN_CSHARP_MULTIPLE_INHERITANCE      833 %enddef
-%define SWIGWARN_CSHARP_TYPEMAP_GETCPTR_UNDEF     834 %enddef
-%define SWIGWARN_CSHARP_TYPEMAP_CLASSMOD_UNDEF    835 %enddef
-%define SWIGWARN_CSHARP_TYPEMAP_CSBODY_UNDEF      836 %enddef
-%define SWIGWARN_CSHARP_TYPEMAP_CSOUT_UNDEF       837 %enddef
-%define SWIGWARN_CSHARP_TYPEMAP_CSIN_UNDEF        838 %enddef
-%define SWIGWARN_CSHARP_TYPEMAP_CSDIRECTORIN_UNDEF    839 %enddef
-%define SWIGWARN_CSHARP_TYPEMAP_CSDIRECTOROUT_UNDEF   840 %enddef
-%define SWIGWARN_CSHARP_COVARIANT_RET             842 %enddef
-%define SWIGWARN_CSHARP_TYPEMAP_CSCONSTRUCT_UNDEF 843 %enddef
-%define SWIGWARN_CSHARP_EXCODE                    844 %enddef
-%define SWIGWARN_CSHARP_CANTHROW                  845 %enddef
-%define SWIGWARN_CSHARP_NO_DIRECTORCONNECT_ATTR   846 %enddef
-
-/* please leave 830-849 free for C# */
-
-%define SWIGWARN_MODULA3_TYPEMAP_TYPE_UNDEF        850 %enddef
-%define SWIGWARN_MODULA3_TYPEMAP_GETCPTR_UNDEF     851 %enddef
-%define SWIGWARN_MODULA3_TYPEMAP_CLASSMOD_UNDEF    852 %enddef
-%define SWIGWARN_MODULA3_TYPEMAP_PTRCONSTMOD_UNDEF 853 %enddef
-%define SWIGWARN_MODULA3_TYPEMAP_MULTIPLE_RETURN   854 %enddef
-%define SWIGWARN_MODULA3_MULTIPLE_INHERITANCE      855 %enddef
-%define SWIGWARN_MODULA3_TYPECONSTRUCTOR_UNKNOWN   856 %enddef
-%define SWIGWARN_MODULA3_UNKNOWN_PRAGMA            857 %enddef
-%define SWIGWARN_MODULA3_BAD_ENUMERATION           858 %enddef
-%define SWIGWARN_MODULA3_DOUBLE_ID                 859 %enddef
-%define SWIGWARN_MODULA3_BAD_IMPORT                860 %enddef
-
-/* please leave 850-869 free for Modula 3 */
-
-%define SWIGWARN_PHP_MULTIPLE_INHERITANCE         870 %enddef
-%define SWIGWARN_PHP_UNKNOWN_PRAGMA               871 %enddef
-%define SWIGWARN_PHP_PUBLIC_BASE                  872 %enddef
-
-/* please leave 870-889 free for PHP */
-
-%define SWIGWARN_GO_NAME_CONFLICT                 890 %enddef
-
-/* please leave 890-899 free for Go */
-
-/* -- User defined warnings (900 - 999) -- */
-
diff --git a/share/swig/2.0.11/swigwarnings.swg b/share/swig/2.0.11/swigwarnings.swg
deleted file mode 100644
index 21498eb..0000000
--- a/share/swig/2.0.11/swigwarnings.swg
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
-  Include the internal swig macro codes. These macros correspond to
-  the one found in Source/Include/swigwarn.h plus the 'SWIG' prefix.
-  
-  For example, in the include file 'swigwarn.h' you will find
-
-    #define WARN_TYPEMAP_CHARLEAK ...
-
-  and in the 'swigwarn.swg' interface, you will see
-
-    %define SWIGWARN_TYPEMAP_CHARLEAK ...
-
-  This code can be used in warning filters as follows:
-
-    %warnfilter(SWIGWARN_TYPEMAP_CHARLEAK);
-
-  Warnings messages used in typemaps. Message names will be the same
-  as those in Lib/swigwarn.swg but with the suffix _MSG.
-   
-  For example, for the code SWIGWARN_TYPEMAP_CHARLEAK, once you use
-
-    %typemapmsg(CHARLEAK,<msg>);
-
-  you use the message in your typemap as
-
-    %typemap(varin,warning=SWIGWARN_TYPEMAP_CHARLEAK_MSG) char * 
-
-  while you suppress the warning using
-
-    %warnfilter(SWIGWARN_TYPEMAP_CHARLEAK);
-
-  as described above.
-*/
-
-/* -----------------------------------------------------------------------------
- * SWIG warning codes
- * ----------------------------------------------------------------------------- */
-
-%include <swigwarn.swg>
-
-/* -----------------------------------------------------------------------------
- * Auxiliary macros
- * ----------------------------------------------------------------------------- */
-
-/* Macro to define warning messages */
-#define %_warningmsg(Val, Msg...) `Val`":"Msg 
-#define %warningmsg(Val, Msg...) %_warningmsg(Val, Msg)
-
-/* -----------------------------------------------------------------------------
- *  Typemap related warning messages
- * ----------------------------------------------------------------------------- */
-
-%define SWIGWARN_TYPEMAP_CHARLEAK_MSG         "451:Setting a const char * variable may leak memory." %enddef
-%define SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG     "454:Setting a pointer/reference variable may leak memory." %enddef
-%define SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG    "470:Thread/reentrant unsafe wrapping, consider returning by value instead." %enddef
-%define SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG  "473:Returning a pointer or reference in a director method is not recommended." %enddef
-
-/* -----------------------------------------------------------------------------
- * Operator related warning messages 
- * ----------------------------------------------------------------------------- */
-
-%define SWIGWARN_IGNORE_OPERATOR_NEW_MSG        "350:operator new ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_DELETE_MSG     "351:operator delete ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_PLUS_MSG       "352:operator+ ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_MINUS_MSG      "353:operator- ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_MUL_MSG        "354:operator* ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_DIV_MSG        "355:operator/ ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_MOD_MSG        "356:operator% ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_XOR_MSG        "357:operator^ ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_AND_MSG        "358:operator& ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_OR_MSG         "359:operator| ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_NOT_MSG        "360:operator~ ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_LNOT_MSG       "361:operator! ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_EQ_MSG         "362:operator= ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_LT_MSG         "363:operator< ignored" %enddef
-%define SWIGWARN_IGNORE_OPERATOR_GT_MSG         "364:operator> ignored" %enddef
-%define SWIGWARN_IGNORE_OPERATOR_PLUSEQ_MSG     "365:operator+= ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_MINUSEQ_MSG    "366:operator-= ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_MULEQ_MSG      "367:operator*= ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_DIVEQ_MSG      "368:operator/= ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_MODEQ_MSG      "369:operator%= ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_XOREQ_MSG      "370:operator^= ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_ANDEQ_MSG      "371:operator&= ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_OREQ_MSG       "372:operator|= ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_LSHIFT_MSG     "373:operator<< ignored" %enddef
-%define SWIGWARN_IGNORE_OPERATOR_RSHIFT_MSG     "374:operator>> ignored" %enddef
-%define SWIGWARN_IGNORE_OPERATOR_LSHIFTEQ_MSG   "375:operator<<= ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_RSHIFTEQ_MSG   "376:operator>>= ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_EQUALTO_MSG    "377:operator== ignored" %enddef
-%define SWIGWARN_IGNORE_OPERATOR_NOTEQUAL_MSG   "378:operator!= ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_LTEQUAL_MSG    "379:operator<= ignored" %enddef
-%define SWIGWARN_IGNORE_OPERATOR_GTEQUAL_MSG    "380:operator>= ignored" %enddef
-%define SWIGWARN_IGNORE_OPERATOR_LAND_MSG       "381:operator&& ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_LOR_MSG        "382:operator|| ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_PLUSPLUS_MSG   "383:operator++ ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_MINUSMINUS_MSG "384:operator-- ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_COMMA_MSG      "385:operator-- ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_ARROWSTAR_MSG  "386:operator->* ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_ARROW_MSG      "387:operator-> ignored" %enddef
-%define SWIGWARN_IGNORE_OPERATOR_CALL_MSG       "388:operator() ignored" %enddef
-%define SWIGWARN_IGNORE_OPERATOR_INDEX_MSG      "389:operator[] ignored (consider using %%extend)"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_UPLUS_MSG      "390:operator+ ignored" %enddef
-%define SWIGWARN_IGNORE_OPERATOR_UMINUS_MSG     "391:operator- ignored" %enddef
-%define SWIGWARN_IGNORE_OPERATOR_UMUL_MSG       "392:operator* ignored" %enddef
-%define SWIGWARN_IGNORE_OPERATOR_UAND_MSG       "393:operator& ignored" %enddef
-%define SWIGWARN_IGNORE_OPERATOR_NEWARR_MSG     "394:operator new[] ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_DELARR_MSG     "395:operator delete[] ignored"  %enddef
-%define SWIGWARN_IGNORE_OPERATOR_REF_MSG        "396:operator*() ignored" %enddef
-
-#define %ignoreoperator(Oper) %ignorewarn(SWIGWARN_IGNORE_OPERATOR_##Oper##_MSG)
-
-/* -----------------------------------------------------------------------------
- * Macros for keyword and built-in names 
- * ----------------------------------------------------------------------------- */
-
-#define %keywordwarn(msg...) %namewarn(%warningmsg(SWIGWARN_PARSE_KEYWORD, msg)) 
-#define %builtinwarn(msg...) %namewarn(%warningmsg(SWIGWARN_PARSE_BUILTIN_NAME, msg), %$isfunction)
-
-
-/* -----------------------------------------------------------------------------
- * Warning filter feature
- * ----------------------------------------------------------------------------- */
-
-#define %_warnfilter(filter...) %feature("warnfilter",`filter`)
-#define %warnfilter(filter...) %_warnfilter(filter)
-
-
-
diff --git a/share/swig/2.0.11/tcl/std_map.i b/share/swig/2.0.11/tcl/std_map.i
deleted file mode 100644
index 1b7e769..0000000
--- a/share/swig/2.0.11/tcl/std_map.i
+++ /dev/null
@@ -1,75 +0,0 @@
-//
-// SWIG typemaps for std::map
-// Luigi Ballabio
-// Jan. 2003
-//
-// Common implementation
-
-%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();
-            }
-        }
-    };
-
-// 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/tcl/std_vector.i b/share/swig/2.0.11/tcl/std_vector.i
deleted file mode 100644
index de99a36..0000000
--- a/share/swig/2.0.11/tcl/std_vector.i
+++ /dev/null
@@ -1,419 +0,0 @@
-/* -----------------------------------------------------------------------------
- * std_vector.i
- * ----------------------------------------------------------------------------- */
-
-%include <std_common.i>
-
-// ------------------------------------------------------------------------
-// std::vector
-// 
-// The aim of all that follows would be to integrate std::vector with 
-// Tcl as much as possible, namely, to allow the user to pass and 
-// be returned Tcl lists.
-// const declarations are used to guess the intent of the function being
-// exported; therefore, the following rationale is applied:
-// 
-//   -- f(std::vector< T >), f(const std::vector< T >&), f(const std::vector< T >*):
-//      the parameter being read-only, either a Tcl list or a
-//      previously wrapped std::vector< T > can be passed.
-//   -- f(std::vector< T >&), f(std::vector< T >*):
-//      the parameter must be modified; therefore, only a wrapped std::vector
-//      can be passed.
-//   -- std::vector< T > f():
-//      the vector is returned by copy; therefore, a Tcl list of T:s 
-//      is returned which is most easily used in other Tcl functions procs
-//   -- std::vector< T >& f(), std::vector< T >* f(), const std::vector< T >& f(),
-//      const std::vector< T >* f():
-//      the vector is returned by reference; therefore, a wrapped std::vector
-//      is returned
-// ------------------------------------------------------------------------
-
-%{
-#include <vector>
-#include <algorithm>
-#include <stdexcept>
-#include <string>
-
-Tcl_Obj* SwigString_FromString(const std::string &s) {
-    return Tcl_NewStringObj(s.data(), (int)s.length());
-}
-
-int Tcl_GetBoolFromObj(Tcl_Interp *interp, Tcl_Obj *o, bool *val) {
-  int v;
-  int res = Tcl_GetBooleanFromObj(interp, o, &v);
-  if (res == TCL_OK) {
-    *val = v ? true : false;
-  }
-  return res;  
-}
- 
-int SwigString_AsString(Tcl_Interp *interp, Tcl_Obj *o, std::string *val) {
-    int len;
-    const char* temp = Tcl_GetStringFromObj(o, &len);
-    if (temp == NULL)
-        return TCL_ERROR;
-    val->assign(temp, len);
-    return TCL_OK;
-}
-
-// behaviour of this is such as the real Tcl_GetIntFromObj
-template <typename Type>
-int SwigInt_As(Tcl_Interp *interp, Tcl_Obj *o, Type *val) {
-    int temp_val, return_val;
-    return_val = Tcl_GetIntFromObj(interp, o, &temp_val);
-    *val = (Type) temp_val;
-    return return_val;
-}
-
-// behaviour of this is such as the real Tcl_GetDoubleFromObj
-template <typename Type>
-int SwigDouble_As(Tcl_Interp *interp, Tcl_Obj *o, Type *val) {
-    int return_val;
-    double temp_val;
-    return_val = Tcl_GetDoubleFromObj(interp, o, &temp_val);
-    *val = (Type) temp_val;
-    return return_val;
-}
-
-%}
-
-// exported class
-
-namespace std {
-    
-    template<class T> class vector {
-        %typemap(in) vector< T > (std::vector< T > *v) {
-            Tcl_Obj **listobjv;
-            int       nitems;
-            int       i;
-            T*        temp;
-
-            if (SWIG_ConvertPtr($input, (void **) &v, \
-                                $&1_descriptor, 0) == 0){
-                $1 = *v;
-            } else {
-                // It isn't a vector< T > so it should be a list of T's
-                if(Tcl_ListObjGetElements(interp, $input, \
-                                          &nitems, &listobjv) == TCL_ERROR)
-                    return TCL_ERROR;
-                $1 = std::vector< T >();
-                for (i = 0; i < nitems; i++) {
-                    if ((SWIG_ConvertPtr(listobjv[i],(void **) &temp,
-                                         $descriptor(T *),0)) != 0) {
-                        char message[] = 
-                            "list of " #T " expected";
-                        Tcl_SetResult(interp, message, TCL_VOLATILE);
-                        return TCL_ERROR;
-                    }
-                    $1.push_back(*temp);
-                } 
-            }
-        }
-
-        %typemap(in) const vector< T >* (std::vector< T > *v, std::vector< T > w),
-                     const vector< T >& (std::vector< T > *v, std::vector< T > w) {
-            Tcl_Obj **listobjv;
-            int       nitems;
-            int       i;
-            T*        temp;
-
-            if(SWIG_ConvertPtr($input, (void **) &v, \
-                               $&1_descriptor, 0) == 0) {
-                $1 = v;
-            } else {
-                // It isn't a vector< T > so it should be a list of T's
-                if(Tcl_ListObjGetElements(interp, $input, 
-                                          &nitems, &listobjv) == TCL_ERROR)
-                    return TCL_ERROR;
-                w = std::vector< T >();
-                for (i = 0; i < nitems; i++) {
-                    if ((SWIG_ConvertPtr(listobjv[i],(void **) &temp,
-                                         $descriptor(T *),0)) != 0) {
-                        char message[] = 
-                            "list of " #T " expected";
-                        Tcl_SetResult(interp, message, TCL_VOLATILE);
-                        return TCL_ERROR;
-                    }
-                    w.push_back(*temp);
-                } 
-                $1 = &w;
-            }
-        }
-
-        %typemap(out) vector< T > {
-            for (unsigned int i=0; i<$1.size(); i++) {
-                T* ptr = new T((($1_type &)$1)[i]);
-                Tcl_ListObjAppendElement(interp, $result, \
-                                         SWIG_NewInstanceObj(ptr, 
-                                                             $descriptor(T *), 
-                                                             0));
-            }
-        }
-
-        %typecheck(SWIG_TYPECHECK_VECTOR) vector< T > {
-            Tcl_Obj **listobjv;
-            int       nitems;
-            T*        temp;
-            std::vector< T > *v;
-            
-            if(SWIG_ConvertPtr($input, (void **) &v, \
-                               $&1_descriptor, 0) == 0) {
-                /* wrapped vector */
-                $1 = 1;
-            } else {
-                // It isn't a vector< T > so it should be a list of T's
-                if(Tcl_ListObjGetElements(interp, $input, 
-                                          &nitems, &listobjv) == TCL_ERROR)
-                    $1 = 0;
-                else
-                    if (nitems == 0)
-                        $1 = 1;
-                //check the first value to see if it is of correct type
-                    else if ((SWIG_ConvertPtr(listobjv[0],
-                                              (void **) &temp, 
-                                              $descriptor(T *),0)) != 0)
-                        $1 = 0;
-                    else
-                        $1 = 1;
-            }
-        }
-        
-        %typecheck(SWIG_TYPECHECK_VECTOR) const vector< T >&,
-                                          const vector< T >* {
-            Tcl_Obj **listobjv;
-            int       nitems;
-            T*         temp;
-            std::vector< T > *v;
-
-            if(SWIG_ConvertPtr($input, (void **) &v, \
-                               $1_descriptor, 0) == 0){
-                /* wrapped vector */
-                $1 = 1;
-            } else {
-                // It isn't a vector< T > so it should be a list of T's
-                if(Tcl_ListObjGetElements(interp, $input, 
-                                          &nitems, &listobjv) == TCL_ERROR)
-                    $1 = 0;
-                else
-                    if (nitems == 0)
-                        $1 = 1;
-                //check the first value to see if it is of correct type
-                    else if ((SWIG_ConvertPtr(listobjv[0],
-                                              (void **) &temp,
-                                              $descriptor(T *),0)) != 0)
-                        $1 = 0;
-                    else
-                        $1 = 1;
-            }
-        }
-      
-      public:
-        vector(unsigned int size = 0);
-        vector(unsigned int size, const T& value);
-        vector(const vector< T > &);
-
-        unsigned int size() const;
-        bool empty() const;
-        void clear();
-        %rename(push) push_back;
-        void push_back(const T& x);
-        %extend {
-            T pop() throw (std::out_of_range) {
-                if (self->size() == 0)
-                    throw std::out_of_range("pop from empty vector");
-                T x = self->back();
-                self->pop_back();
-                return x;
-            }
-            T& get(int i) throw (std::out_of_range) {
-                int size = int(self->size());
-                if (i<0) i += 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 T& x) throw (std::out_of_range) {
-                int size = int(self->size());
-                if (i<0) i+= size;
-                if (i>=0 && i<size)
-                    (*self)[i] = x;
-                else
-                    throw std::out_of_range("vector index out of range");
-            }
-        }
-    };
-
-
-    // specializations for built-ins
-
-    %define specialize_std_vector(T, CONVERT_FROM, CONVERT_TO)
-    template<> class vector< T > {
-
-        %typemap(in) vector< T > (std::vector< T > *v){
-            Tcl_Obj **listobjv;
-            int       nitems;
-            int       i;
-            T         temp;
-
-            if(SWIG_ConvertPtr($input, (void **) &v, \
-                               $&1_descriptor, 0) == 0) {
-                $1 = *v;
-            } else {
-                // It isn't a vector< T > so it should be a list of T's
-                if(Tcl_ListObjGetElements(interp, $input, 
-                                          &nitems, &listobjv) == TCL_ERROR)
-                    return TCL_ERROR;					      
-                $1 = std::vector< T >();
-                for (i = 0; i < nitems; i++) {
-                    if (CONVERT_FROM(interp, listobjv[i], &temp) == TCL_ERROR)
-                        return TCL_ERROR;
-                    $1.push_back(temp);
-                } 
-            }
-        }
-      
-        %typemap(in) const vector< T >& (std::vector< T > *v,std::vector< T > w),
-                     const vector< T >* (std::vector< T > *v,std::vector< T > w) {
-            Tcl_Obj **listobjv;
-            int       nitems;
-            int       i;
-            T         temp;
-
-            if(SWIG_ConvertPtr($input, (void **) &v, \
-                               $1_descriptor, 0) == 0) {
-                $1 = v;
-            } else {
-                // It isn't a vector< T > so it should be a list of T's
-                if(Tcl_ListObjGetElements(interp, $input, 
-                                          &nitems, &listobjv) == TCL_ERROR)
-                    return TCL_ERROR;
-                w = std::vector< T >();
-                for (i = 0; i < nitems; i++) {
-                    if (CONVERT_FROM(interp, listobjv[i], &temp) == TCL_ERROR)
-                        return TCL_ERROR;
-                    w.push_back(temp);
-                } 
-                $1 = &w;
-            }
-        }
-
-        %typemap(out) vector< T > {
-            for (unsigned int i=0; i<$1.size(); i++) {
-                Tcl_ListObjAppendElement(interp, $result, \
-                                         CONVERT_TO((($1_type &)$1)[i]));
-            }
-        }
-       
-        %typecheck(SWIG_TYPECHECK_VECTOR) vector< T > {
-            Tcl_Obj **listobjv;
-            int       nitems;
-            T         temp;
-            std::vector< T > *v;
-
-            if(SWIG_ConvertPtr($input, (void **) &v, \
-                               $&1_descriptor, 0) == 0){
-                /* wrapped vector */
-                $1 = 1;
-            } else {
-                // It isn't a vector< T > so it should be a list of T's
-                if(Tcl_ListObjGetElements(interp, $input, 
-                                          &nitems, &listobjv) == TCL_ERROR)
-                    $1 = 0;
-                else
-                    if (nitems == 0)
-                        $1 = 1;
-                //check the first value to see if it is of correct type
-                if (CONVERT_FROM(interp, listobjv[0], &temp) == TCL_ERROR)
-                    $1 = 0;
-                else
-                    $1 = 1;
-            }
-        }      
-
-        %typecheck(SWIG_TYPECHECK_VECTOR) const vector< T >&,
-	                                      const vector< T >*{
-            Tcl_Obj **listobjv;
-            int       nitems;
-            T         temp;
-            std::vector< T > *v;
-
-            if(SWIG_ConvertPtr($input, (void **) &v, \
-                               $1_descriptor, 0) == 0){
-                /* wrapped vector */
-                $1 = 1;
-            } else {
-                // It isn't a vector< T > so it should be a list of T's
-                if(Tcl_ListObjGetElements(interp, $input, 
-                                          &nitems, &listobjv) == TCL_ERROR)
-                    $1 = 0;
-                else
-                    if (nitems == 0)
-                        $1 = 1;
-                //check the first value to see if it is of correct type
-                if (CONVERT_FROM(interp, listobjv[0], &temp) == TCL_ERROR)
-                    $1 = 0;
-                else
-                    $1 = 1;
-            }
-        }
-        
-      public:
-        vector(unsigned int size = 0);
-        vector(unsigned int size, const T& value);
-        vector(const vector< T > &);
-
-        unsigned int size() const;
-        bool empty() const;
-        void clear();
-        %rename(push) push_back;
-        void push_back(T x);
-        %extend {
-            T pop() throw (std::out_of_range) {
-                if (self->size() == 0)
-                    throw std::out_of_range("pop from empty vector");
-                T x = self->back();
-                self->pop_back();
-                return x;
-            }
-            T get(int i) throw (std::out_of_range) {
-                int size = int(self->size());
-                if (i<0) i += size;
-                if (i>=0 && i<size)
-                    return (*self)[i];
-                else
-                    throw std::out_of_range("vector index out of range");
-            }
-            void set(int i, T x) throw (std::out_of_range) {
-                int size = int(self->size());
-                if (i<0) i+= size;
-                if (i>=0 && i<size)
-                    (*self)[i] = x;
-                else
-                    throw std::out_of_range("vector index out of range");
-            }
-        }
-    };
-    %enddef
-
-    specialize_std_vector(bool, Tcl_GetBoolFromObj, Tcl_NewBooleanObj);
-    specialize_std_vector(char, SwigInt_As<char>,Tcl_NewIntObj);
-    specialize_std_vector(int, Tcl_GetIntFromObj,Tcl_NewIntObj);
-    specialize_std_vector(short, SwigInt_As<short>, Tcl_NewIntObj);
-    specialize_std_vector(long, SwigInt_As<long>, Tcl_NewIntObj);
-    specialize_std_vector(unsigned char, 
-                          SwigInt_As<unsigned char>, Tcl_NewIntObj);
-    specialize_std_vector(unsigned int, 
-                          SwigInt_As<unsigned int>, Tcl_NewIntObj);
-    specialize_std_vector(unsigned short, 
-                          SwigInt_As<unsigned short>, Tcl_NewIntObj);
-    specialize_std_vector(unsigned long, 
-                          SwigInt_As<unsigned long>, Tcl_NewIntObj);
-    specialize_std_vector(double, Tcl_GetDoubleFromObj, Tcl_NewDoubleObj);
-    specialize_std_vector(float, SwigDouble_As<float>, Tcl_NewDoubleObj);
-    specialize_std_vector(std::string, 
-                          SwigString_AsString, SwigString_FromString);
-
-}
-
-
diff --git a/share/swig/2.0.11/tcl/tclprimtypes.swg b/share/swig/2.0.11/tcl/tclprimtypes.swg
deleted file mode 100644
index e781798..0000000
--- a/share/swig/2.0.11/tcl/tclprimtypes.swg
+++ /dev/null
@@ -1,239 +0,0 @@
-/* ------------------------------------------------------------
- * Primitive Types
- * ------------------------------------------------------------ */
-
-/* boolean */
-
-%fragment(SWIG_From_frag(bool),"header") {
-  %define_as(SWIG_From_dec(bool),           Tcl_NewBooleanObj)
-}
-
-%fragment(SWIG_AsVal_frag(bool),"header") {
-SWIGINTERN int
-SWIG_AsVal_dec(bool)(Tcl_Obj *obj, bool *val)
-{
-  int v;
-  if (Tcl_GetBooleanFromObj(0, obj, &v) == TCL_OK) {
-    if (val) *val = v ? true : false;
-    return SWIG_OK;
-  }
-  return SWIG_TypeError;
-}
-}
-
-/* long */
-
-%fragment(SWIG_From_frag(long),"header",
-	  fragment="<limits.h>") {
-SWIGINTERNINLINE Tcl_Obj* 
-SWIG_From_dec(long)(long value)
-{
-  if (((long) INT_MIN <= value) && (value <= (long) INT_MAX)) {
-    return Tcl_NewIntObj(%numeric_cast(value,int));
-  } else {
-    return Tcl_NewLongObj(value);
-  }
-}
-}
-
-%fragment(SWIG_AsVal_frag(long),"header") {
-SWIGINTERN int
-SWIG_AsVal_dec(long)(Tcl_Obj *obj, long* val)
-{
-  long v;
-  if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
-    if (val) *val = (long) v;
-    return SWIG_OK;
-  }
-  return SWIG_TypeError;
-}
-}
-
-/* unsigned long */
-
-%fragment(SWIG_From_frag(unsigned long),"header",
-	  fragment=SWIG_From_frag(long),
-	  fragment="<stdio.h>") {
-SWIGINTERNINLINE Tcl_Obj* 
-SWIG_From_dec(unsigned long)(unsigned long value)
-{
-  if (value < (unsigned long) LONG_MAX) {
-    return SWIG_From(long)(%numeric_cast(value, long));
-  } else {
-    char temp[256]; 
-    sprintf(temp, "%lu", value);
-    return Tcl_NewStringObj(temp,-1);
-  }
-}
-}
-
-%fragment(SWIG_AsVal_frag(unsigned long),"header",
-	  fragment="<limits.h>") {
-SWIGINTERN int
-SWIG_AsVal_dec(unsigned long)(Tcl_Obj *obj, unsigned long *val) {
-  long v;
-  if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
-    if (v >= 0) {
-      if (val) *val = (unsigned long) v;
-      return SWIG_OK;
-    }
-    /* If v is negative, then this could be a negative number, or an
-       unsigned value which doesn't fit in a signed long, so try to
-       get it as a string so we can distinguish these cases. */
-  }
-  {
-    int len = 0;
-    const char *nptr = Tcl_GetStringFromObj(obj, &len);
-    if (nptr && len > 0) {
-      char *endptr;
-      unsigned long v;
-      if (*nptr == '-') return SWIG_OverflowError;
-      errno = 0;
-      v = strtoul(nptr, &endptr,0);
-      if (nptr[0] == '\0' || *endptr != '\0')
-	return SWIG_TypeError;
-      if (v == ULONG_MAX && errno == ERANGE) {
-	errno = 0;
-	return SWIG_OverflowError;
-      } else {
-	if (*endptr == '\0') {
-	  if (val) *val = v;
-	  return SWIG_OK;
-	}
-      }
-    }
-  }
-  
-  return SWIG_TypeError;
-}
-}
-
-/* long long */
-
-%fragment(SWIG_From_frag(long long),"header",
-	  fragment=SWIG_From_frag(long),
-	  fragment="<limits.h>",
-	  fragment="<stdio.h>") {
-SWIGINTERNINLINE Tcl_Obj* 
-SWIG_From_dec(long long)(long long value)
-{
-  if (((long long) LONG_MIN <= value) && (value <= (long long) LONG_MAX)) {
-    return SWIG_From(long)(%numeric_cast(value,long));
-  } else {    
-    char temp[256]; 
-    sprintf(temp, "%lld", value);
-    return Tcl_NewStringObj(temp,-1);
-  }
-}
-}
-
-%fragment(SWIG_AsVal_frag(long long),"header",
-	  fragment="<limits.h>",
-	  fragment="<stdlib.h>") {
-SWIGINTERN int
-SWIG_AsVal_dec(long long)(Tcl_Obj *obj, long long *val)
-{
-  long v;
-  if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
-    if (val) *val = v;
-    return SWIG_OK;
-  } else {
-    int len = 0;
-    const char *nptr = Tcl_GetStringFromObj(obj, &len);
-    if (nptr && len > 0) {
-      char *endptr;
-      long long v;
-      errno = 0;
-      v = strtoll(nptr, &endptr,0);
-      if (nptr[0] == '\0' || *endptr != '\0')
-	return SWIG_TypeError;
-      if ((v == LLONG_MAX || v == LLONG_MIN) && errno == ERANGE) {
-	errno = 0;
-	return SWIG_OverflowError;
-      } else {
-	if (*endptr == '\0') {
-	  if (val) *val = v;
-	  return SWIG_OK;
-	}
-      }
-    }
-  }
-  return SWIG_TypeError;
-}
-}
-
-/* unsigned long long */
-
-%fragment(SWIG_From_frag(unsigned long long),"header",
-	  fragment=SWIG_From_frag(long long),
-	  fragment="<limits.h>",
-	  fragment="<stdio.h>") {
-SWIGINTERNINLINE Tcl_Obj* 
-SWIG_From_dec(unsigned long long)(unsigned long long value)
-{
-  if (value < (unsigned long long) LONG_MAX) {
-    return SWIG_From(long long)(%numeric_cast(value, long long));
-  } else {
-    char temp[256]; 
-    sprintf(temp, "%llu", value);
-    return Tcl_NewStringObj(temp,-1);
-  }
-}
-}
-
-%fragment(SWIG_AsVal_frag(unsigned long long),"header",
-	  fragment=SWIG_AsVal_frag(unsigned long),
-	  fragment="<limits.h>",
-	  fragment="<stdlib.h>") {
-SWIGINTERN int
-SWIG_AsVal_dec(unsigned long long)(Tcl_Obj *obj, unsigned long long *val)
-{
-  long v;
-  if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
-    if (val) *val = (unsigned long) v;
-    return SWIG_OK;
-  } else {
-    int len = 0;
-    const char *nptr = Tcl_GetStringFromObj(obj, &len);
-    if (nptr && len > 0) {
-      char *endptr;
-      unsigned long long v;
-      if (*nptr == '-') return SWIG_OverflowError;
-      errno = 0;
-      v = strtoull(nptr, &endptr,0);
-      if (nptr[0] == '\0' || *endptr != '\0')
-	return SWIG_TypeError;
-      if (v == ULLONG_MAX && errno == ERANGE) {
-	errno = 0;
-	return SWIG_OverflowError;
-      } else {
-	if (*endptr == '\0') {
-	  if (val) *val = v;
-	  return SWIG_OK;
-	}
-      }
-    }
-  }
-  return SWIG_TypeError;
-}
-}
-
-/* double */
-
-%fragment(SWIG_From_frag(double),"header") {
-  %define_as(SWIG_From(double),         Tcl_NewDoubleObj)
-}
-
-%fragment(SWIG_AsVal_frag(double),"header") {
-SWIGINTERN int
-SWIG_AsVal_dec(double)(Tcl_Obj *obj, double *val)
-{
-  double v;
-  if (Tcl_GetDoubleFromObj(0, obj, &v) == TCL_OK) {
-    if (val) *val = v;
-    return SWIG_OK;
-  }
-  return SWIG_TypeError;
-}
-}
-
diff --git a/share/swig/2.0.11/tcl/tclrun.swg b/share/swig/2.0.11/tcl/tclrun.swg
deleted file mode 100644
index c91a7e5..0000000
--- a/share/swig/2.0.11/tcl/tclrun.swg
+++ /dev/null
@@ -1,685 +0,0 @@
-/* -----------------------------------------------------------------------------
- * tclrun.swg
- *
- * This file contains the runtime support for Tcl modules and includes
- * code for managing global variables and pointer type checking.
- * ----------------------------------------------------------------------------- */
-
-/* Common SWIG API */
-
-/* for raw pointers */
-#define SWIG_ConvertPtr(oc, ptr, ty, flags)             SWIG_Tcl_ConvertPtr(interp, oc, ptr, ty, flags)
-#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Tcl_NewPointerObj(ptr, type, flags)
-
-/* for raw packed data */
-#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Tcl_ConvertPacked(interp, obj, ptr, sz, ty)
-#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Tcl_NewPackedObj(ptr, sz, type)
-
-/* for class or struct pointers */
-#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_Tcl_ConvertPtr(interp, obj, pptr, type, flags)
-#define SWIG_NewInstanceObj(thisvalue, type, flags)     SWIG_Tcl_NewInstanceObj(interp, thisvalue, type, flags)
-
-/* for C or C++ function pointers */
-#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Tcl_ConvertPtr(interp, obj, pptr, type, 0)
-#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Tcl_NewPointerObj(ptr, type, 0)
-
-/* for C++ member pointers, ie, member methods */
-#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Tcl_ConvertPacked(interp,obj, ptr, sz, ty)
-#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Tcl_NewPackedObj(ptr, sz, type)
-
-
-/* Runtime API */
-
-#define SWIG_GetModule(clientdata)                      SWIG_Tcl_GetModule((Tcl_Interp *) (clientdata))	     
-#define SWIG_SetModule(clientdata, pointer)          	SWIG_Tcl_SetModule((Tcl_Interp *) (clientdata), pointer)
-
-
-/* Error manipulation */
-
-#define SWIG_ErrorType(code)                            SWIG_Tcl_ErrorType(code)                                      
-#define SWIG_Error(code, msg)            		SWIG_Tcl_SetErrorMsg(interp, SWIG_Tcl_ErrorType(code), msg)
-#define SWIG_fail                        		goto fail						    
-
-
-/* Tcl-specific SWIG API */
-
-#define SWIG_Acquire(ptr)                               SWIG_Tcl_Acquire(ptr)                                     
-#define SWIG_MethodCommand                           	SWIG_Tcl_MethodCommand				       
-#define SWIG_Disown(ptr)                             	SWIG_Tcl_Disown(ptr)				       
-#define SWIG_ConvertPtrFromString(c, ptr, ty, flags) 	SWIG_Tcl_ConvertPtrFromString(interp, c, ptr, ty, flags)  
-#define SWIG_MakePtr(c, ptr, ty, flags)              	SWIG_Tcl_MakePtr(c, ptr, ty, flags)		       
-#define SWIG_PointerTypeFromString(c)                	SWIG_Tcl_PointerTypeFromString(c)			       
-#define SWIG_GetArgs                                 	SWIG_Tcl_GetArgs					       
-#define SWIG_GetConstantObj(key)                     	SWIG_Tcl_GetConstantObj(key)			       
-#define SWIG_ObjectConstructor                       	SWIG_Tcl_ObjectConstructor				       
-#define SWIG_Thisown(ptr)                            	SWIG_Tcl_Thisown(ptr)				       
-#define SWIG_ObjectDelete                            	SWIG_Tcl_ObjectDelete				       
-
-
-#define SWIG_TCL_DECL_ARGS_2(arg1, arg2)                (Tcl_Interp *interp SWIGUNUSED, arg1, arg2)
-#define SWIG_TCL_CALL_ARGS_2(arg1, arg2)                (interp, arg1, arg2)
-/* -----------------------------------------------------------------------------
- * pointers/data manipulation
- * ----------------------------------------------------------------------------- */
-
-/* For backward compatibility only */
-#define SWIG_POINTER_EXCEPTION  0
-#define SWIG_GetConstant        SWIG_GetConstantObj
-#define SWIG_Tcl_GetConstant    SWIG_Tcl_GetConstantObj
-
-#include "assert.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Object support */
-
-SWIGRUNTIME Tcl_HashTable*
-SWIG_Tcl_ObjectTable(void) {
-  static Tcl_HashTable  swigobjectTable;
-  static int            swigobjectTableinit = 0;
-  if (!swigobjectTableinit) {
-    Tcl_InitHashTable(&swigobjectTable, TCL_ONE_WORD_KEYS);
-    swigobjectTableinit = 1;
-  }
-  return &swigobjectTable;
-}
-
-/* Acquire ownership of a pointer */
-SWIGRUNTIME void
-SWIG_Tcl_Acquire(void *ptr) {
-  int newobj;
-  Tcl_CreateHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr, &newobj);
-}
-
-SWIGRUNTIME int
-SWIG_Tcl_Thisown(void *ptr) {
-  if (Tcl_FindHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr)) {
-    return 1;
-  }
-  return 0;
-}
-
-/* Disown a pointer.  Returns 1 if we owned it to begin with */
-SWIGRUNTIME int
-SWIG_Tcl_Disown(void *ptr) {
-  Tcl_HashEntry *entryPtr = Tcl_FindHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr);
-  if (entryPtr) {
-    Tcl_DeleteHashEntry(entryPtr);
-    return 1;
-  }
-  return 0;
-}
-
-/* Convert a pointer value */
-SWIGRUNTIME int
-SWIG_Tcl_ConvertPtrFromString(Tcl_Interp *interp, const char *c, void **ptr, swig_type_info *ty, int flags) {
-  swig_cast_info *tc;
-  /* Pointer values must start with leading underscore */
-  while (*c != '_') {
-    *ptr = (void *) 0;
-    if (strcmp(c,"NULL") == 0) return SWIG_OK;
-
-    /* Empty string: not a pointer */
-    if (*c == 0) return SWIG_ERROR; 
-
-    /* Hmmm. It could be an object name. */
-
-    /* Check if this is a command at all. Prevents <c> cget -this         */
-    /* from being called when c is not a command, firing the unknown proc */
-    if (Tcl_VarEval(interp,"info commands ", c, (char *) NULL) == TCL_OK) {
-      Tcl_Obj *result = Tcl_GetObjResult(interp);
-      if (*(Tcl_GetStringFromObj(result, NULL)) == 0) {
-        /* It's not a command, so it can't be a pointer */
-        Tcl_ResetResult(interp);
-        return SWIG_ERROR;
-      }
-    } else {
-      /* This will only fail if the argument is multiple words. */
-      /* Multiple words are also not commands.                  */
-      Tcl_ResetResult(interp);
-      return SWIG_ERROR;
-    }
-
-    /* Check if this is really a SWIG pointer */
-    if (Tcl_VarEval(interp,c," cget -this", (char *) NULL) != TCL_OK) {
-      Tcl_ResetResult(interp);
-      return SWIG_ERROR;
-    }
-
-    c = Tcl_GetStringFromObj(Tcl_GetObjResult(interp), NULL);
-  }
-
-  c++;
-  c = SWIG_UnpackData(c,ptr,sizeof(void *));
-  if (ty) {
-    tc = c ? SWIG_TypeCheck(c,ty) : 0;
-    if (!tc) {
-      return SWIG_ERROR;
-    }
-    if (flags & SWIG_POINTER_DISOWN) {
-      SWIG_Disown((void *) *ptr);
-    }
-    {
-      int newmemory = 0;
-      *ptr = SWIG_TypeCast(tc,(void *) *ptr,&newmemory);
-      assert(!newmemory); /* newmemory handling not yet implemented */
-    }
-  }
-  return SWIG_OK;
-}
-
-/* Convert a pointer value */
-SWIGRUNTIMEINLINE int
-SWIG_Tcl_ConvertPtr(Tcl_Interp *interp, Tcl_Obj *oc, void **ptr, swig_type_info *ty, int flags) {
-  return SWIG_Tcl_ConvertPtrFromString(interp, Tcl_GetStringFromObj(oc,NULL), ptr, ty, flags);
-}
-
-/* Convert a pointer value */
-SWIGRUNTIME char *
-SWIG_Tcl_PointerTypeFromString(char *c) {
-  char d;
-  /* Pointer values must start with leading underscore. NULL has no type */
-  if (*c != '_') {
-    return 0;
-  }
-  c++;
-  /* Extract hex value from pointer */
-  while ((d = *c)) {
-    if (!(((d >= '0') && (d <= '9')) || ((d >= 'a') && (d <= 'f')))) break;
-    c++;
-  }
-  return c;
-}
-
-/* Convert a packed value value */
-SWIGRUNTIME int
-SWIG_Tcl_ConvertPacked(Tcl_Interp *SWIGUNUSEDPARM(interp) , Tcl_Obj *obj, void *ptr, int sz, swig_type_info *ty) {
-  swig_cast_info *tc;
-  const char  *c;
-
-  if (!obj) goto type_error;
-  c = Tcl_GetStringFromObj(obj,NULL);
-  /* Pointer values must start with leading underscore */
-  if (*c != '_') goto type_error;
-  c++;
-  c = SWIG_UnpackData(c,ptr,sz);
-  if (ty) {
-    tc = SWIG_TypeCheck(c,ty);
-    if (!tc) goto type_error;
-  }
-  return SWIG_OK;
-
- type_error:
-
-  return SWIG_ERROR;
-}
-
-
-/* Take a pointer and convert it to a string */
-SWIGRUNTIME void
-SWIG_Tcl_MakePtr(char *c, void *ptr, swig_type_info *ty, int flags) {
-  if (ptr) {
-    *(c++) = '_';
-    c = SWIG_PackData(c,&ptr,sizeof(void *));
-    strcpy(c,ty->name);
-  } else {
-    strcpy(c,(char *)"NULL");
-  }
-  flags = 0;
-}
-
-/* Create a new pointer object */
-SWIGRUNTIMEINLINE Tcl_Obj *
-SWIG_Tcl_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
-  Tcl_Obj *robj;
-  char result[SWIG_BUFFER_SIZE];
-  SWIG_MakePtr(result,ptr,type,flags);
-  robj = Tcl_NewStringObj(result,-1);
-  return robj;
-}
-
-SWIGRUNTIME Tcl_Obj *
-SWIG_Tcl_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
-  char result[1024];
-  char *r = result;
-  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
-  *(r++) = '_';
-  r = SWIG_PackData(r,ptr,sz);
-  strcpy(r,type->name);
-  return Tcl_NewStringObj(result,-1);
-}
-
-/* -----------------------------------------------------------------------------*
- *  Get type list 
- * -----------------------------------------------------------------------------*/
-
-SWIGRUNTIME swig_module_info * 
-SWIG_Tcl_GetModule(Tcl_Interp *interp) {
-  const char *data;
-  swig_module_info *ret = 0;
-  
-  /* first check if pointer already created */
-  data = Tcl_GetVar(interp, (char *)"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TCL_GLOBAL_ONLY);
-  if (data) {
-    SWIG_UnpackData(data, &ret, sizeof(swig_type_info **));
-  }
-
-  return ret;
-}
-
-SWIGRUNTIME void
-SWIG_Tcl_SetModule(Tcl_Interp *interp, swig_module_info *module) {
-  char buf[SWIG_BUFFER_SIZE];
-  char *data;
-
-  /* create a new pointer */
-  data = SWIG_PackData(buf, &module, sizeof(swig_type_info **));
-  *data = 0;
-  Tcl_SetVar(interp, (char *)"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, buf, TCL_GLOBAL_ONLY);
-}
-
-/* -----------------------------------------------------------------------------*
- *  Object auxiliars
- * -----------------------------------------------------------------------------*/
-
-
-SWIGRUNTIME void
-SWIG_Tcl_ObjectDelete(ClientData clientData) {
-  swig_instance *si = (swig_instance *) clientData;
-  if ((si) && (si->destroy) && (SWIG_Disown(si->thisvalue))) {
-    if (si->classptr->destructor) {
-      (si->classptr->destructor)(si->thisvalue);
-    }
-  }
-  Tcl_DecrRefCount(si->thisptr);
-  free(si);
-}
-
-/* Function to invoke object methods given an instance */
-SWIGRUNTIME int
-SWIG_Tcl_MethodCommand(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST _objv[]) {
-  char *method,   *attrname;
-  swig_instance   *inst = (swig_instance *) clientData;
-  swig_method     *meth;
-  swig_attribute  *attr;
-  Tcl_Obj         *oldarg;
-  Tcl_Obj         **objv;
-  int              rcode;
-  swig_class      *cls;
-  swig_class      *cls_stack[64];
-  int              cls_stack_bi[64];
-  int              cls_stack_top = 0;
-  int              numconf = 2;
-  int              bi;
-
-  objv = (Tcl_Obj **) _objv;
-  if (objc < 2) {
-    Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
-    return TCL_ERROR;
-  }
-  method = Tcl_GetStringFromObj(objv[1],NULL);
-  if (strcmp(method,"-acquire") == 0) {
-    inst->destroy = 1;
-    SWIG_Acquire(inst->thisvalue);
-    return TCL_OK;
-  }
-  if (strcmp(method,"-disown") == 0) {
-    if (inst->destroy) {
-      SWIG_Disown(inst->thisvalue);
-    }
-    inst->destroy = 0;
-    return TCL_OK;
-  }
-  if (strcmp(method,"-delete") == 0) {
-    Tcl_DeleteCommandFromToken(interp,inst->cmdtok);
-    return TCL_OK;
-  }
-  cls_stack[cls_stack_top] = inst->classptr;
-  cls_stack_bi[cls_stack_top] = -1;
-  cls = inst->classptr;
-  while (1) {
-    Tcl_HashEntry* hashentry;
-    bi = cls_stack_bi[cls_stack_top];
-    cls = cls_stack[cls_stack_top];
-    if (bi != -1) {
-      if (!cls->bases[bi] && cls->base_names[bi]) {
-        /* lookup and cache the base class */
-	swig_type_info *info = SWIG_TypeQueryModule(cls->module, cls->module, cls->base_names[bi]);
-	if (info) cls->bases[bi] = (swig_class *) info->clientdata;
-      }
-      cls = cls->bases[bi];
-      if (cls) {
-        cls_stack_bi[cls_stack_top]++;
-        cls_stack_top++;
-        cls_stack[cls_stack_top] = cls;
-        cls_stack_bi[cls_stack_top] = -1;
-        continue;
-      }
-    }
-    if (!cls) {
-      cls_stack_top--;
-      if (cls_stack_top < 0) break;
-      else continue;
-    }
-    cls_stack_bi[cls_stack_top]++;
-
-    hashentry = Tcl_FindHashEntry(&(cls->hashtable), method);
-    if (hashentry) {
-        ClientData cd = Tcl_GetHashValue(hashentry);
-        swig_wrapper method_wrapper = (swig_wrapper)cd;
-        oldarg = objv[1];
-        objv[1] = inst->thisptr;
-        Tcl_IncrRefCount(inst->thisptr);
-        rcode = (method_wrapper)(clientData,interp,objc,objv);
-        objv[1] = oldarg;
-        Tcl_DecrRefCount(inst->thisptr);
-        return rcode;
-    }
-    /* Check class methods for a match */
-    if (strcmp(method,"cget") == 0) {
-      if (objc < 3) {
-        Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
-        return TCL_ERROR;
-      }
-      attrname = Tcl_GetStringFromObj(objv[2],NULL);
-      attr = cls->attributes;
-      while (attr && attr->name) {
-        if ((strcmp(attr->name, attrname) == 0) && (attr->getmethod)) {
-          oldarg = objv[1];
-          objv[1] = inst->thisptr;
-          Tcl_IncrRefCount(inst->thisptr);
-          rcode = (*attr->getmethod)(clientData,interp,2, objv);
-          objv[1] = oldarg;
-          Tcl_DecrRefCount(inst->thisptr);
-          return rcode;
-        }
-        attr++;
-      }
-      if (strcmp(attrname, "-this") == 0) {
-        Tcl_SetObjResult(interp, Tcl_DuplicateObj(inst->thisptr));
-        return TCL_OK;
-      }
-      if (strcmp(attrname, "-thisown") == 0) {
-        if (SWIG_Thisown(inst->thisvalue)) {
-          Tcl_SetResult(interp,(char*)"1",TCL_STATIC);
-        } else {
-          Tcl_SetResult(interp,(char*)"0",TCL_STATIC);
-        }
-        return TCL_OK;
-      }
-    } else if (strcmp(method, "configure") == 0) {
-      int i;
-      if (objc < 4) {
-        Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
-        return TCL_ERROR;
-      }
-      i = 2;
-      while (i < objc) {
-        attrname = Tcl_GetStringFromObj(objv[i],NULL);
-        attr = cls->attributes;
-        while (attr && attr->name) {
-          if ((strcmp(attr->name, attrname) == 0) && (attr->setmethod)) {
-            oldarg = objv[i];
-            objv[i] = inst->thisptr;
-            Tcl_IncrRefCount(inst->thisptr);
-            rcode = (*attr->setmethod)(clientData,interp,3, &objv[i-1]);
-            objv[i] = oldarg;
-            Tcl_DecrRefCount(inst->thisptr);
-            if (rcode != TCL_OK) return rcode;
-            numconf += 2;
-          }
-          attr++;
-        }
-        i+=2;
-      }
-    }
-  }
-  if (strcmp(method,"configure") == 0) {
-    if (numconf >= objc) {
-      return TCL_OK;
-    } else {
-      Tcl_SetResult(interp,(char *) "Invalid attribute name.", TCL_STATIC);
-      return TCL_ERROR;
-    }
-  }
-  if (strcmp(method,"cget") == 0) {
-    Tcl_SetResult(interp,(char *) "Invalid attribute name.", TCL_STATIC);
-    return TCL_ERROR;
-  }
-  Tcl_SetResult(interp, (char *) "Invalid method. Must be one of: configure cget -acquire -disown -delete", TCL_STATIC);
-  cls = inst->classptr;
-  bi = 0;
-  while (cls) {
-    meth = cls->methods;
-    while (meth && meth->name) {
-      char *cr = (char *) Tcl_GetStringResult(interp);
-      size_t meth_len = strlen(meth->name);
-      char* where = strchr(cr,':');
-      while(where) {
-        where = strstr(where, meth->name);
-        if(where) {
-          if(where[-1] == ' ' && (where[meth_len] == ' ' || where[meth_len]==0)) {
-            break;
-          } else {
-            where++;
-          }
-        }
-      }
-
-      if (!where)
-        Tcl_AppendElement(interp, (char *) meth->name);
-      meth++;
-    }
-    cls = inst->classptr->bases[bi++];
-  }
-  return TCL_ERROR;
-}
-
-/* This function takes the current result and turns it into an object command */
-SWIGRUNTIME Tcl_Obj *
-SWIG_Tcl_NewInstanceObj(Tcl_Interp *interp, void *thisvalue, swig_type_info *type, int flags) {
-  Tcl_Obj *robj = SWIG_NewPointerObj(thisvalue, type,0);
-  /* Check to see if this pointer belongs to a class or not */
-  if (thisvalue && (type->clientdata) && (interp)) {
-    Tcl_CmdInfo    ci;
-    char          *name;
-    name = Tcl_GetStringFromObj(robj,NULL);
-    if (!Tcl_GetCommandInfo(interp,name, &ci) || (flags)) {
-      swig_instance *newinst = (swig_instance *) malloc(sizeof(swig_instance));
-      newinst->thisptr = Tcl_DuplicateObj(robj);
-      Tcl_IncrRefCount(newinst->thisptr);
-      newinst->thisvalue = thisvalue;
-      newinst->classptr = (swig_class *) type->clientdata;
-      newinst->destroy = flags;
-      newinst->cmdtok = Tcl_CreateObjCommand(interp, Tcl_GetStringFromObj(robj,NULL), (swig_wrapper_func) SWIG_MethodCommand, (ClientData) newinst, (swig_delete_func) SWIG_ObjectDelete);
-      if (flags) {
-        SWIG_Acquire(thisvalue);
-      }
-    }
-  }
-  return robj;
-}
-
-/* Function to create objects */
-SWIGRUNTIME int
-SWIG_Tcl_ObjectConstructor(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
-  Tcl_Obj          *newObj = 0;
-  void             *thisvalue = 0;
-  swig_instance   *newinst = 0;
-  swig_class      *classptr = (swig_class *) clientData;
-  swig_wrapper     cons = 0;
-  char             *name = 0;
-  int               firstarg = 0;
-  int               thisarg = 0;
-  int               destroy = 1;
-
-  if (!classptr) {
-    Tcl_SetResult(interp, (char *) "swig: internal runtime error. No class object defined.", TCL_STATIC);
-    return TCL_ERROR;
-  }
-  cons = classptr->constructor;
-  if (objc > 1) {
-    char *s = Tcl_GetStringFromObj(objv[1],NULL);
-    if (strcmp(s,"-this") == 0) {
-      thisarg = 2;
-      cons = 0;
-    } else if (strcmp(s,"-args") == 0) {
-      firstarg = 1;
-    } else if (objc == 2) {
-      firstarg = 1;
-      name = s;
-    } else if (objc >= 3) {
-      char *s1;
-      name = s;
-      s1 = Tcl_GetStringFromObj(objv[2],NULL);
-      if (strcmp(s1,"-this") == 0) {
-	thisarg = 3;
-	cons = 0;
-      } else {
-	firstarg = 1;
-      }
-    }
-  }
-  if (cons) {
-    int result;
-    result = (*cons)(0, interp, objc-firstarg, &objv[firstarg]);
-    if (result != TCL_OK) {
-      return result;
-    }
-    newObj = Tcl_DuplicateObj(Tcl_GetObjResult(interp));
-    if (!name) name = Tcl_GetStringFromObj(newObj,NULL);
-  } else if (thisarg > 0) {
-    if (thisarg < objc) {
-      destroy = 0;
-      newObj = Tcl_DuplicateObj(objv[thisarg]);
-      if (!name) name = Tcl_GetStringFromObj(newObj,NULL);
-    } else {
-      Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
-      return TCL_ERROR;
-    }
-  } else {
-    Tcl_SetResult(interp, (char *) "No constructor available.", TCL_STATIC);
-    return TCL_ERROR;
-  }
-  if (SWIG_Tcl_ConvertPtr(interp,newObj, (void **) &thisvalue, *(classptr->type), 0) != SWIG_OK) {
-    Tcl_DecrRefCount(newObj);
-    return TCL_ERROR;
-  }
-  newinst = (swig_instance *) malloc(sizeof(swig_instance));
-  newinst->thisptr = newObj;
-  Tcl_IncrRefCount(newObj);
-  newinst->thisvalue = thisvalue;
-  newinst->classptr = classptr;
-  newinst->destroy = destroy;
-  if (destroy) {
-    SWIG_Acquire(thisvalue);
-  }
-  newinst->cmdtok = Tcl_CreateObjCommand(interp,name, (swig_wrapper) SWIG_MethodCommand, (ClientData) newinst, (swig_delete_func) SWIG_ObjectDelete);
-  return TCL_OK;
-}
-
-/* -----------------------------------------------------------------------------*
- *   Get arguments 
- * -----------------------------------------------------------------------------*/
-SWIGRUNTIME int
-SWIG_Tcl_GetArgs(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], const char *fmt, ...) {
-  int        argno = 0, opt = 0;
-  long       tempi;
-  double     tempd;
-  const char *c;
-  va_list    ap;
-  void      *vptr;
-  Tcl_Obj   *obj = 0;
-  swig_type_info *ty;
-
-  va_start(ap,fmt);
-  for (c = fmt; (*c && (*c != ':') && (*c != ';')); c++,argno++) {
-    if (*c == '|') {
-      opt = 1;
-      c++;
-    }
-    if (argno >= (objc-1)) {
-      if (!opt) {
-        Tcl_SetResult(interp, (char *) "Wrong number of arguments ", TCL_STATIC);
-        goto argerror;
-      } else {
-        va_end(ap);
-        return TCL_OK;
-      }
-    }
-
-    vptr = va_arg(ap,void *);
-    if (vptr) {
-      if (isupper(*c)) {
-        obj = SWIG_Tcl_GetConstantObj(Tcl_GetStringFromObj(objv[argno+1],0));
-        if (!obj) obj = objv[argno+1];
-      } else {
-        obj = objv[argno+1];
-      }
-      switch(*c) {
-      case 'i': case 'I':
-      case 'l': case 'L':
-      case 'h': case 'H':
-      case 'b': case 'B':
-        if (Tcl_GetLongFromObj(interp,obj,&tempi) != TCL_OK) goto argerror;
-        if ((*c == 'i') || (*c == 'I')) *((int *)vptr) = (int)tempi;
-        else if ((*c == 'l') || (*c == 'L')) *((long *)vptr) = (long)tempi;
-        else if ((*c == 'h') || (*c == 'H')) *((short*)vptr) = (short)tempi;
-        else if ((*c == 'b') || (*c == 'B')) *((unsigned char *)vptr) = (unsigned char)tempi;
-        break;
-      case 'f': case 'F':
-      case 'd': case 'D':
-        if (Tcl_GetDoubleFromObj(interp,obj,&tempd) != TCL_OK) goto argerror;
-        if ((*c == 'f') || (*c == 'F')) *((float *) vptr) = (float)tempd;
-        else if ((*c == 'd') || (*c == 'D')) *((double*) vptr) = tempd;
-        break;
-      case 's': case 'S':
-        if (*(c+1) == '#') {
-          int *vlptr = (int *) va_arg(ap, void *);
-          *((char **) vptr) = Tcl_GetStringFromObj(obj, vlptr);
-          c++;
-        } else {
-          *((char **)vptr) = Tcl_GetStringFromObj(obj,NULL);
-        }
-        break;
-      case 'c': case 'C':
-        *((char *)vptr) = *(Tcl_GetStringFromObj(obj,NULL));
-        break;
-      case 'p': case 'P':
-        ty = (swig_type_info *) va_arg(ap, void *);
-        if (SWIG_Tcl_ConvertPtr(interp, obj, (void **) vptr, ty, 0) != SWIG_OK) goto argerror;
-        break;
-      case 'o': case 'O':
-        *((Tcl_Obj **)vptr) = objv[argno+1];
-        break;
-      default:
-        break;
-      }
-    }
-  }
-
-  if ((*c != ';') && ((objc-1) > argno)) {
-    Tcl_SetResult(interp, (char *) "Wrong # args.", TCL_STATIC);
-    goto argerror;
-  }
-  va_end(ap);
-  return TCL_OK;
-
- argerror:
-  {
-    char temp[32];
-    sprintf(temp,"%d", argno+1);
-    c = strchr(fmt,':');
-    if (!c) c = strchr(fmt,';');
-    if (!c) c = (char *)"";
-    Tcl_AppendResult(interp,c," argument ", temp, NULL);
-    va_end(ap);
-    return TCL_ERROR;
-  }
-}
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/share/swig/2.0.11/tcl/tcltypemaps.swg b/share/swig/2.0.11/tcl/tcltypemaps.swg
deleted file mode 100644
index 2b4e06e..0000000
--- a/share/swig/2.0.11/tcl/tcltypemaps.swg
+++ /dev/null
@@ -1,90 +0,0 @@
-/* ------------------------------------------------------------
- *  Typemap specializations for Tcl
- * ------------------------------------------------------------ */
-
-/* ------------------------------------------------------------
- *  Fragment section
- * ------------------------------------------------------------ */
-
-/*
-  In Tcl we need to pass the interp value, so we define the decl/call
-  macros as needed.
-*/
-
-#define SWIG_AS_DECL_ARGS SWIG_TCL_DECL_ARGS_2
-#define SWIG_AS_CALL_ARGS SWIG_TCL_CALL_ARGS_2
-
-
-/* Include fundamental fragment definitions */
-%include <typemaps/fragments.swg>
-
-/* Look for user fragments file. */
-%include <tclfragments.swg>
-
-/* Tcl fragments for primitive types */
-%include <tclprimtypes.swg>
-
-/* Tcl fragments for char* strings */
-%include <tclstrings.swg>
-
-
-/* ------------------------------------------------------------
- *  Unified typemap section
- * ------------------------------------------------------------ */
-
-/* No director support in Tcl */
-#ifdef SWIG_DIRECTOR_TYPEMAPS
-#undef SWIG_DIRECTOR_TYPEMAPS
-#endif
-
-
-/* Tcl types */
-#define SWIG_Object                      Tcl_Obj *
-
-/* Overload of the output/constant/exception handling */
-
-/* output */
-#define %set_output(obj)                 Tcl_SetObjResult(interp,obj)
-
-/* append output */
-#define %append_output(obj)              Tcl_ListObjAppendElement(interp,Tcl_GetObjResult(interp),obj)
-
-/* set constant */
-#define SWIG_SetConstant(name, obj)      SWIG_Tcl_SetConstantObj(interp, name, obj)
-
-/* raise */
-#define SWIG_Raise(obj,type,desc)        SWIG_Tcl_SetErrorObj(interp,type,obj)
-
-
-/* Include the unified typemap library */
-%include <typemaps/swigtypemaps.swg>
-
-
-/* ------------------------------------------------------------
- *  Tcl extra typemaps / typemap overrides
- * ------------------------------------------------------------ */
-
-#if 1
-// Old 1.3.25 typemaps needed to avoid premature object deletion
-%typemap(out,noblock=1) SWIGTYPE *INSTANCE, SWIGTYPE &INSTANCE, SWIGTYPE INSTANCE[] {
-  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( %as_voidptr($1), $1_descriptor,0));
-}
-
-%typemap(out) SWIGTYPE *DYNAMIC, SWIGTYPE &DYNAMIC {
-  swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor,%as_voidptrptr(&$1));
-  Tcl_SetObjResult(interp,SWIG_NewInstanceObj(%as_voidptr($1), ty,0));
-}
-
-#endif
-
-%typemap(throws,noblock=1) SWIGTYPE CLASS {
-  SWIG_set_result(SWIG_NewInstanceObj(%as_voidptr(SWIG_new_copy($1, $1_ltype)), $&1_descriptor, 1));
-  SWIG_fail;
-}
-
-%typemap(out)    SWIGTYPE    =  SWIGTYPE INSTANCE;
-%typemap(out)    SWIGTYPE *  =  SWIGTYPE *INSTANCE;
-%typemap(out)    SWIGTYPE *const  =  SWIGTYPE *;
-%typemap(out)    SWIGTYPE &  =  SWIGTYPE &INSTANCE;
-%typemap(out)    SWIGTYPE [] =  SWIGTYPE INSTANCE[];
-%typemap(varout) SWIGTYPE    =  SWIGTYPE INSTANCE;
diff --git a/share/swig/2.0.11/typemaps/attribute.swg b/share/swig/2.0.11/typemaps/attribute.swg
deleted file mode 100644
index 46fc80f..0000000
--- a/share/swig/2.0.11/typemaps/attribute.swg
+++ /dev/null
@@ -1,283 +0,0 @@
-/* -----------------------------------------------------------------------------
- * attribute.swg
- *
- * Attribute implementation
- * ----------------------------------------------------------------------------- */
-
-/*
-  The following macros convert a pair of set/get methods
-  into a "native" attribute.
-
-  Use %attribute when you have a pair of get/set methods to a primitive type
-  like in:
-
-      %attribute(A, int, a, get_a, set_a);
-
-      struct A
-      {
-        int get_a() const;
-        void set_a(int aa);
-      };
-
-  If you don't provide a 'set' method, a 'read-only' attribute
-  is generated, ie, like in:
-
-      %attribute(A, int, c, get_c);
-
-  Use %attributeref when you have const/non-const reference access methods
-  for primitive types or class/structs, like in:
-
-      %attributeref(A, int, b);
-
-      struct A
-      {
-        const int& b() const;
-        int& b();
-      };
-
-      %attributeref(B, int, c);
-
-      struct B
-      {
-        int& c();
-      };
-
-  You can also use
-
-      %attributeref(Class, AttributeType, AttributeName, AccessorMethod)
-
-  if the internal C++ reference methods have a different name from the
-  attribute you want, so
-
-      %attributeref(B, int, d, c);
-
-  is the same as the last example, but instead of the attribute 'c' being
-  called 'c', it is called 'd'.
-
-  Now you can use the attributes like so:
-
-      x = A()
-      x.a = 3        # calls A::set_a
-      print x.a      # calls A::get_a
-
-      x.b = 3        # calls A::b()
-      print x.b      # calls A::b() const
-
-  Use %attribute2 instead of %attribute to indicate that reference-pointer
-  translation is required. You use %attribute2 instead of %attribute in
-  cases like this:
- 
-  %attribute2(MyClass, MyFoo, Foo, GetFoo, SetFoo);
-  %inline %{
-    struct MyFoo { 
-      int x;
-    };
-    class MyClass {
-      MyFoo foo;
-    public:
-      MyFoo& GetFoo() { return foo; }
-      void SetFoo(const MyFoo& other) { foo = other; }
-    };
-  %}
-
-  Here, the data type of the property is a wrapped type (MyFoo) and on the
-  C++ side it is passed by reference. The problem is that the SWIG wrapper will
-  pass around a pointer (MyFoo *) which is not compatible with the reference
-  type of the accessors (MyFoo &). Therefore, if you use %attribute, you'll get
-  an error from your C/C++ compiler. %attribute2 translates between a pointer
-  and a reference to eliminate the error. In case you're confused, let's make it
-  simple: just use %attribute at first, but if the C/C++ compiler gives an error
-  while compiling the wrapper, try %attribute2 instead.
-
-  NOTE: remember that if the type contains commas, such as 'std::pair<int,int>',
-  you need to use the macro like:
-
-  %attributeref(A, %arg(std::pair<int,int>), pval);
-
-  where %arg() 'normalizes' the type to be understood as a single
-  argument, otherwise the macro will get confused by the comma.
-
-  The %attributeval is the same as %attribute, but should be used when the type
-  is a class/struct (ie a non-primitive type) and when the get and set methods 
-  return/pass by value. The following is very similar to the above example, but 
-  note that the access is by value rather than reference.
-
-    %attributeval(MyClassVal, MyFoo, ReadWriteFoo, GetFoo, SetFoo);
-    %attributeval(MyClassVal, MyFoo, ReadOnlyFoo, GetFoo);
-    %inline %{
-      class MyClassVal {
-	MyFoo foo;
-      public:
-	MyFoo GetFoo() { return foo; }
-	void SetFoo(MyFoo other) { foo = other; }
-      };
-    %} 
-
-  The %attributestring is the same as %attributeval, but should be used for string
-  class types, which are unusual as they are a class on the C++ side, but normally an
-  immutable/primitive type in the target language. Example usage for std::string:
-
-    %include <std_string.i>
-    %attributestring(MyStringyClass, std::string, ReadWriteString, GetString, SetString);
-    %attributestring(MyStringyClass, std::string, ReadOnlyString, GetString);
-    %inline %{
-      class MyStringyClass {
-	std::string str;
-      public:
-	MyStringyClass(const std::string &val) : str(val) {}
-	std::string GetString() { return str; }
-	void SetString(std::string other) { str = other; }
-      };
-    %} 
-
-*/
-
-//
-// Define SWIG_ATTRIBUTE_TEMPLATE if you want to use templates instead of macros for the C++ get and set wrapper methods
-// Does not always generate compileable code, use at your peril!
-//
-//#define SWIG_ATTRIBUTE_TEMPLATE
-
-%define %attribute_custom(Class, AttributeType, AttributeName, GetMethod, SetMethod, GetMethodCall, SetMethodCall)
-  %ignore Class::GetMethod();
-  %ignore Class::GetMethod() const;
-  #if #SetMethod != #AttributeName
-    %ignore Class::SetMethod;
-  #endif
-  %extend Class {
-    AttributeType AttributeName;
-  }
-#if defined(__cplusplus) && defined(SWIG_ATTRIBUTE_TEMPLATE)
-  %{
-    template < class C > inline AttributeType %mangle(Class) ##_## AttributeName ## _get(const C* self_) {
-      return GetMethodCall;
-    }
-    template < class C > inline AttributeType %mangle(Class) ##_## AttributeName ## _get(C* self_) {
-      return GetMethodCall;
-    }
-    template < class C > inline void %mangle(Class) ##_## AttributeName ## _set(C* self_, AttributeType val_) {
-      SetMethodCall;
-    }
-  %}
-#else
-  %{
-    #define %mangle(Class) ##_## AttributeName ## _get(self_) GetMethodCall
-    #define %mangle(Class) ##_## AttributeName ## _set(self_, val_) SetMethodCall
-  %}
-#endif
-%enddef
-
-%define %attribute_readonly(Class, AttributeType, AttributeName, GetMethod, GetMethodCall)
-  %ignore Class::GetMethod();
-  %ignore Class::GetMethod() const;
-  %immutable Class::AttributeName;
-  %extend Class {
-    AttributeType AttributeName;
-  }
-#if defined(__cplusplus) && defined(SWIG_ATTRIBUTE_TEMPLATE)
-  %{
-    template < class C > inline AttributeType %mangle(Class) ##_## AttributeName ## _get(const C* self_) {
-      return GetMethodCall;
-    }
-    template < class C > inline AttributeType %mangle(Class) ##_## AttributeName ## _get(C* self_) {
-      return GetMethodCall;
-    }
-  %}
-#else
-  %{
-    #define %mangle(Class) ##_## AttributeName ## _get(self_) GetMethodCall
-  %}
-#endif
-%enddef
-
-
-// User macros
-
-%define %attribute(Class, AttributeType, AttributeName, GetMethod, SetMethod...)
-  #if #SetMethod != ""
-    %attribute_custom(%arg(Class), %arg(AttributeType), AttributeName, GetMethod, SetMethod, self_->GetMethod(), self_->SetMethod(val_))
-  #else
-    %attribute_readonly(%arg(Class), %arg(AttributeType), AttributeName, GetMethod, self_->GetMethod())
-  #endif
-%enddef
-
-%define %attribute2(Class, AttributeType, AttributeName, GetMethod, SetMethod...)
-  #if #SetMethod != ""
-    %attribute_custom(%arg(Class), %arg(AttributeType), AttributeName, GetMethod, SetMethod, &self_->GetMethod(), self_->SetMethod(*val_))
-  #else
-    %attribute_readonly(%arg(Class), %arg(AttributeType), AttributeName, GetMethod, &self_->GetMethod())
-  #endif
-%enddef
-
-%define %attributeref(Class, AttributeType, AttributeName, AccessorMethod...)
-  #if #AccessorMethod != ""
-    %attribute_custom(%arg(Class), %arg(AttributeType), AttributeName, AccessorMethod, AccessorMethod, self_->AccessorMethod(), self_->AccessorMethod() = val_)
-  #else
-    %attribute_custom(%arg(Class), %arg(AttributeType), AttributeName, AttributeName, AttributeName, self_->AttributeName(), self_->AttributeName() = val_)
-  #endif
-%enddef
-
-%define %attribute2ref(Class, AttributeType, AttributeName, AccessorMethod...)
-  #if #AccessorMethod != ""
-    %attribute_custom(%arg(Class), %arg(AttributeType), AttributeName, AccessorMethod, AccessorMethod, &self_->AccessorMethod(), self_->AccessorMethod() = *val_)
-  #else
-    %attribute_custom(%arg(Class), %arg(AttributeType), AccessorName, AccessorName, AccessorName, &self_->AccessorName(), self_->AccessorName() = *val_)
-  #endif
-%enddef
-
-// deprecated (same as %attributeref, but there is an argument order inconsistency)
-%define %attribute_ref(Class, AttributeType, AccessorMethod, AttributeName...)
-  #if #AttributeName != ""
-    %attribute_custom(%arg(Class), %arg(AttributeType), AttributeName, AccessorMethod, AccessorMethod, self_->AccessorMethod(), self_->AccessorMethod() = val_)
-  #else
-    %attribute_custom(%arg(Class), %arg(AttributeType), AccessorMethod, AccessorMethod, AccessorMethod, self_->AccessorMethod(), self_->AccessorMethod() = val_)
-  #endif
-%enddef
-
-
-%define %attributeval(Class, AttributeType, AttributeName, GetMethod, SetMethod...)
-  %{
-    #define %mangle(Class) ##_## AttributeName ## _get(self_) new AttributeType(self_->GetMethod())
-  %}
-  #if #SetMethod != ""
-    %{
-      #define %mangle(Class) ##_## AttributeName ## _set(self_, val_) self_->SetMethod(*val_)
-    %}
-    #if #SetMethod != #AttributeName
-      %ignore Class::SetMethod;
-    #endif
-  #else
-    %immutable Class::AttributeName;
-  #endif
-  %ignore Class::GetMethod();
-  %ignore Class::GetMethod() const;
-  %newobject Class::AttributeName;
-  %extend Class {
-    AttributeType AttributeName;
-  }
-%enddef
-
-
-%define %attributestring(Class, AttributeType, AttributeName, GetMethod, SetMethod...)
-  %{
-    #define %mangle(Class) ##_## AttributeName ## _get(self_) *new AttributeType(self_->GetMethod())
-  %}
-  #if #SetMethod != ""
-    %{
-      #define %mangle(Class) ##_## AttributeName ## _set(self_, val_) self_->SetMethod(val_)
-    %}
-    #if #SetMethod != #AttributeName
-      %ignore Class::SetMethod;
-    #endif
-  #else
-    %immutable Class::AttributeName;
-  #endif
-  %ignore Class::GetMethod();
-  %ignore Class::GetMethod() const;
-  %newobject Class::AttributeName;
-  %typemap(newfree) const AttributeType &AttributeName "delete $1;// my newfree override"
-  %extend Class {
-    AttributeType AttributeName;
-  }
-%enddef
-
diff --git a/share/swig/2.0.11/typemaps/cstrings.swg b/share/swig/2.0.11/typemaps/cstrings.swg
deleted file mode 100644
index 7fe6a3f..0000000
--- a/share/swig/2.0.11/typemaps/cstrings.swg
+++ /dev/null
@@ -1,288 +0,0 @@
-/* -----------------------------------------------------------------------------
- * cstrings.swg
- *
- * This file provides typemaps and macros for dealing with various forms
- * of C character string handling.   The primary use of this module
- * is in returning character data that has been allocated or changed in
- * some way.
- * ----------------------------------------------------------------------------- */
-
-%define %typemaps_cstring(Name, Char,
-			  SWIG_AsCharPtr,
-			  SWIG_AsCharPtrAndSize,
-			  SWIG_FromCharPtr,
-			  SWIG_FromCharPtrAndSize)
-
-
-/* %cstring_input_binary(TYPEMAP, SIZE)
- * 
- * Macro makes a function accept binary string data along with
- * a size.  For example:
- *
- *     %cstring_input_binary(Char *buff, int size);
- *     void foo(Char *buff, int size) {
- *     }
- *
- */
-
-%define Name ## _input_binary(TYPEMAP, SIZE)                   
-%typemap(in,noblock=1,fragment=#SWIG_AsCharPtrAndSize) (TYPEMAP, SIZE) 
-  (int res, Char *buf = 0, size_t size = 0, int alloc = 0)  {
-  res = SWIG_AsCharPtrAndSize($input, &buf, &size, &alloc);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "(TYPEMAP, SIZE)", $symname, $argnum);
-  }
-  $1 = ($1_ltype) buf;					       
-  $2 = ($2_ltype) size - 1;				       
-}
-%typemap(freearg,noblock=1,match="in") (TYPEMAP, SIZE) {
-  if (alloc$argnum == SWIG_NEWOBJ) %delete_array(buf$argnum);
-}
-%enddef								
-
-
-
-/*
- * %cstring_bounded_output(TYPEMAP, MAX)
- *
- * This macro is used to return a NULL-terminated output string of
- * some maximum length.  For example:
- *
- *     %cstring_bounded_output(Char *outx, 512);
- *     void foo(Char *outx) {
- *         sprintf(outx,"blah blah\n");
- *     }
- *
- */
-
-%define Name ## _bounded_output(TYPEMAP,MAX)        
-%typemap(in,noblock=1,numinputs=0) TYPEMAP (Char temp[MAX+1])  {
-  $1 = ($1_ltype) temp;
-}
-%typemap(freearg,match="in") TYPEMAP "";
-%typemap(argout,noblock=1,fragment= #SWIG_FromCharPtr ) TYPEMAP {
-  $1[MAX] = 0;  
-  %append_output(SWIG_FromCharPtr($1));
-}
-%enddef
-
-
-
-/*
- * %cstring_chunk_output(TYPEMAP, SIZE)
- *
- * This macro is used to return a chunk of binary string data.
- * Embedded NULLs are okay.  For example:
- *
- *     %cstring_chunk_output(Char *outx, 512);
- *     void foo(Char *outx) {
- *         memmove(outx, somedata, 512);
- *     }
- *
- */
-
-%define Name ## _chunk_output(TYPEMAP,SIZE)           
-%typemap(in,noblock=1,numinputs=0) TYPEMAP(Char temp[SIZE]) {
-  $1 = ($1_ltype) temp;
-}
-%typemap(freearg,match="in") TYPEMAP "";
-%typemap(argout,noblock=1,fragment= #SWIG_FromCharPtrAndSize) TYPEMAP {
-  %append_output(SWIG_FromCharPtrAndSize($1,SIZE));
-}
-%enddef
-
-
-
-/*
- * %cstring_bounded_mutable(TYPEMAP, SIZE)
- *
- * This macro is used to wrap a string that's going to mutate.
- *
- *     %cstring_bounded_mutable(Char *in, 512);
- *     void foo(in *x) {
- *         while (*x) {
- *            *x = toupper(*x);
- *            x++;
- *         }
- *     }
- *
- */
-
-
-%define Name ## _bounded_mutable(TYPEMAP,MAX)                              
-%typemap(in,noblock=1,fragment=#SWIG_AsCharPtrAndSize) TYPEMAP 
-  (int res,Char temp[MAX+1], Char *t = 0, size_t n = 0, int alloc = 0) {  
-  res = SWIG_AsCharPtrAndSize($input, &t, &n, &alloc);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "TYPEMAP", $symname, $argnum);
-  }
-  if ( n > (size_t) MAX ) n = (size_t) MAX;
-  memcpy(temp, t, sizeof(Char)*n);
-  if (alloc == SWIG_NEWOBJ) %delete_array(t);
-  temp[n - 1] = 0;                                                             
-  $1 = ($1_ltype) temp;                                                    
-}
-%typemap(freearg,match="in") TYPEMAP "";
-%typemap(argout,noblock=1,fragment=#SWIG_FromCharPtr) TYPEMAP {
-  $1[MAX] = 0;
-  %append_output(SWIG_FromCharPtr($1));
-}
-%enddef
-
-
-/*
- * %cstring_mutable(TYPEMAP [, expansion])
- *
- * This macro is used to wrap a string that will mutate in place.
- * It may change size up to a user-defined expansion. 
- *
- *     %cstring_mutable(Char *in);
- *     void foo(in *x) {
- *         while (*x) {
- *            *x = toupper(*x);
- *            x++;
- *         }
- *     }
- *
- */
-
-%define Name ## _mutable(TYPEMAP,EXP...)                  
-%typemap(in,noblock=1,fragment=#SWIG_AsCharPtrAndSize) TYPEMAP (int res, Char *t = 0, size_t n = 0, int alloc = 0, size_t expansion = 0) {
-#if #EXP != ""
-  expansion += EXP;
-#endif
-  res = SWIG_AsCharPtrAndSize($input, &t, &n, &alloc);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "TYPEMAP", $symname, $argnum);
-  }
-  $1 = %new_array(n+expansion, $*1_ltype);          
-  memcpy($1,t,sizeof(Char)*n);
-  if (alloc == SWIG_NEWOBJ) %delete_array(t);
-  $1[n-1] = 0;
-}
-%typemap(freearg,match="in") TYPEMAP "";
-%typemap(argout,noblock=1,fragment=#SWIG_FromCharPtr) TYPEMAP { 
-  %append_output(SWIG_FromCharPtr($1));
-  %delete_array($1);                                  
-}
-%enddef
-
-
-/*
- * %cstring_output_maxsize(TYPEMAP, SIZE)
- *
- * This macro returns data in a string of some user-defined size.
- *
- *     %cstring_output_maxsize(Char *outx, int max) {
- *     void foo(Char *outx, int max) {
- *         sprintf(outx,"blah blah\n");
- *     }
- */
-
-%define Name ## _output_maxsize(TYPEMAP, SIZE)                       
-%typemap(in,noblock=1,fragment=SWIG_AsVal_frag(size_t)) (TYPEMAP, SIZE) (int res, size_t size, Char *buff = 0) {   
-  res = SWIG_AsVal(size_t)($input, &size);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "(TYPEMAP, SIZE)", $symname, $argnum);
-  }
-  buff= %new_array(size+1, Char);
-  $2 = %numeric_cast(size, $2_ltype);
-  $1 = %static_cast(buff, $1_ltype);
-}
-%typemap(freearg,noblock=1,match="in") (TYPEMAP,SIZE) {
-  if (buff$argnum) %delete_array(buff$argnum);
-} 
-%typemap(argout,noblock=1,fragment=#SWIG_FromCharPtr) (TYPEMAP,SIZE) { 
-  %append_output(SWIG_FromCharPtr($1));
-}
-%enddef
-
-/*
- * %cstring_output_withsize(TYPEMAP, SIZE)
- *
- * This macro is used to return Character data along with a size
- * parameter.
- *
- *     %cstring_output_maxsize(Char *outx, int *max) {
- *     void foo(Char *outx, int *max) {
- *         sprintf(outx,"blah blah\n");
- *         *max = strlen(outx);  
- *     }
- */
-
-%define Name ## _output_withsize(TYPEMAP, SIZE)                        
-%typemap(in,noblock=1,fragment=SWIG_AsVal_frag(size_t)) (TYPEMAP, SIZE) (int res, size_t n, Char *buff = 0, $*2_ltype size) {    
-  res = SWIG_AsVal(size_t)($input, &n);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "(TYPEMAP, SIZE)", $symname, $argnum);
-  }
-  buff= %new_array(n+1, Char);
-  $1 = %static_cast(buff, $1_ltype);
-  size = %numeric_cast(n,$*2_ltype);
-  $2 = &size;
-}								       
-%typemap(freearg,noblock=1,match="in")(TYPEMAP,SIZE) {
-  if (buff$argnum) %delete_array(buff$argnum);
-} 
-%typemap(argout,noblock=1,fragment=#SWIG_FromCharPtrAndSize) (TYPEMAP,SIZE) { 
-  %append_output(SWIG_FromCharPtrAndSize($1,*$2));
-}
-%enddef
-
-
-/*
- * %cstring_output_allocate(TYPEMAP, RELEASE)
- *
- * This macro is used to return Character data that was
- * allocated with new or malloc.
- *
- *     %cstring_output_allocated(Char **outx, free($1));
- *     void foo(Char **outx) {
- *         *outx = (Char *) malloc(512);
- *         sprintf(outx,"blah blah\n");
- *     }
- */
- 
-%define Name ## _output_allocate(TYPEMAP, RELEASE)           
-%typemap(in,noblock=1,numinputs=0) TYPEMAP($*1_ltype temp = 0) {
-  $1 = &temp;
-}
-%typemap(freearg,match="in") TYPEMAP "";
-%typemap(argout,noblock=1,fragment=#SWIG_FromCharPtr) TYPEMAP { 
-  if (*$1) {
-    %append_output(SWIG_FromCharPtr(*$1));
-    RELEASE;					  	     
-  }					  	     
-}							     
-%enddef
-
-
-/*
- * %cstring_output_allocate_size(TYPEMAP, SIZE, RELEASE)
- *
- * This macro is used to return Character data that was
- * allocated with new or malloc.
- *
- *     %cstring_output_allocated(Char **outx, int *sz, free($1));
- *     void foo(Char **outx, int *sz) {
- *         *outx = (Char *) malloc(512);
- *         sprintf(outx,"blah blah\n");
- *         *sz = strlen(outx);
- *     }
- */
-
-%define Name ## _output_allocate_size(TYPEMAP, SIZE, RELEASE)
-%typemap(in,noblock=1,numinputs=0) (TYPEMAP, SIZE) ($*1_ltype temp = 0, $*2_ltype tempn) {
-  $1 = &temp; $2 = &tempn;
-}
-%typemap(freearg,match="in") (TYPEMAP,SIZE) "";
-%typemap(argout,noblock=1,fragment=#SWIG_FromCharPtrAndSize)(TYPEMAP,SIZE) {   
-  if (*$1) {
-    %append_output(SWIG_FromCharPtrAndSize(*$1,*$2));
-    RELEASE;
-  }
-}
-%enddef
-
-%enddef
-
diff --git a/share/swig/2.0.11/typemaps/enumint.swg b/share/swig/2.0.11/typemaps/enumint.swg
deleted file mode 100644
index 854d6f3..0000000
--- a/share/swig/2.0.11/typemaps/enumint.swg
+++ /dev/null
@@ -1,28 +0,0 @@
-/* ------------------------------------------------------------
- *  Enums mapped as integer values
- * ------------------------------------------------------------ */
-
-%apply int { enum SWIGTYPE };
-%apply const int& { const enum SWIGTYPE& };
-
-%typemap(in,fragment=SWIG_AsVal_frag(int),noblock=1) const enum SWIGTYPE& (int val, int ecode, $basetype temp) {  
-  ecode = SWIG_AsVal(int)($input, &val);
-  if (!SWIG_IsOK(ecode)) {
-    %argument_fail(ecode, "$type", $symname, $argnum);
-  } else {
-    temp = %static_cast(val,$basetype);
-    $1 = &temp;
-  }
-}
-
-%typemap(varin,fragment=SWIG_AsVal_frag(int),noblock=1) enum SWIGTYPE {
-  if (sizeof(int) != sizeof($1)) {
-    %variable_fail(SWIG_AttributeError,"$type", "arch, read-only $name");
-  }  else {
-    int ecode = SWIG_AsVal(int)($input, %reinterpret_cast(&$1,int*));
-    if (!SWIG_IsOK(ecode)) {
-      %variable_fail(ecode, "$type", "$name");
-    }
-  }
-}
-
diff --git a/share/swig/2.0.11/typemaps/exception.swg b/share/swig/2.0.11/typemaps/exception.swg
deleted file mode 100644
index 12c4ea6..0000000
--- a/share/swig/2.0.11/typemaps/exception.swg
+++ /dev/null
@@ -1,86 +0,0 @@
-/* -----------------------------------------------------------------------------
- * exceptions.swg
- *
- * This SWIG library file provides language independent exception handling
- * ----------------------------------------------------------------------------- */
-
-%include <typemaps/swigmacros.swg>
-
-
-/* macros for error manipulation */
-#define %nullref_fmt()                     "invalid null reference "		   
-#define %varfail_fmt(_type,_name)          "in variable '"`_name`"' of type '"`_type`"'"
-#ifndef %argfail_fmt
-#define %argfail_fmt(_type,_name,_argn)    "in method '" `_name` "', argument " `_argn`" of type '" `_type`"'"
-#endif
-#define %outfail_fmt(_type)                "in output value of type '"_type"'"
-#ifndef	%argnullref_fmt
-#define %argnullref_fmt(_type,_name,_argn) %nullref_fmt() %argfail_fmt(_type, _name, _argn)
-#endif  
-#define %varnullref_fmt(_type,_name)       %nullref_fmt() %varfail_fmt(_type, _name)  		   
-#define %outnullref_fmt(_type)             %nullref_fmt() %outfail_fmt(_type)         
-
-/* setting an error */
-#define %error(code,msg...)               SWIG_Error(code, msg)
-#define %type_error(msg...)               SWIG_Error(SWIG_TypeError,  msg)
-
-
-
-%insert("runtime") {
-
-%define_as(SWIG_exception_fail(code, msg), %block(%error(code, msg); SWIG_fail))
-
-%define_as(SWIG_contract_assert(expr, msg), if (!(expr)) { %error(SWIG_RuntimeError, msg); SWIG_fail; } else)
-
-}
-
-#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_fail(SWIG_UnknownError, "Unknown exception");
-    }
-  }
-*/
-%{
-#include <stdexcept>
-%}
-%define SWIG_CATCH_STDEXCEPT
-  /* catching std::exception  */
-  catch (std::invalid_argument& e) {
-    SWIG_exception_fail(SWIG_ValueError, e.what() );
-  } catch (std::domain_error& e) {
-    SWIG_exception_fail(SWIG_ValueError, e.what() );
-  } catch (std::overflow_error& e) {
-    SWIG_exception_fail(SWIG_OverflowError, e.what() );
-  } catch (std::out_of_range& e) {
-    SWIG_exception_fail(SWIG_IndexError, e.what() );
-  } catch (std::length_error& e) {
-    SWIG_exception_fail(SWIG_IndexError, e.what() );
-  } catch (std::runtime_error& e) {
-    SWIG_exception_fail(SWIG_RuntimeError, e.what() );
-  } catch (std::exception& e) {
-    SWIG_exception_fail(SWIG_SystemError, e.what() );
-  }
-%enddef
-%define SWIG_CATCH_UNKNOWN
-  catch (std::exception& e) {
-    SWIG_exception_fail(SWIG_SystemError, e.what() );
-  }
-  catch (...) {
-    SWIG_exception_fail(SWIG_UnknownError, "unknown exception");
-  }
-%enddef
-
-
-#endif /* __cplusplus */
diff --git a/share/swig/2.0.11/typemaps/fragments.swg b/share/swig/2.0.11/typemaps/fragments.swg
deleted file mode 100644
index 8f887e3..0000000
--- a/share/swig/2.0.11/typemaps/fragments.swg
+++ /dev/null
@@ -1,269 +0,0 @@
-/*
-  Fragments
-  =========
-  See the "Typemap fragments" section in the documentation for understanding
-  fragments. Below is some info on how fragments and automatic type
-  specialization is used.
-
-  Macros that make the automatic generation of typemaps easier are provided.
-
-  Consider the following code:
-
-      %fragment(SWIG_From_frag(bool), "header") {     
-      static PyObject*		      
-      SWIG_From_dec(bool)(bool value)	       
-      {					       
-        PyObject *obj = value ? Py_True : Py_False;  
-        Py_INCREF(obj);			       
-        return obj;				       
-      }					       
-      }					       
-      					 
-      %typemap(out, fragment=SWIG_From_frag(bool)) bool {
-        $result = SWIG_From(bool)($1));
-      }
-
-  Here the macros
-
-      SWIG_From_frag  => fragment 
-      SWIG_From_dec   => declaration 
-      SWIG_From       => call 
-      
-  allow you to define/include a fragment, and declare and call the
-  'from-bool' method as needed. In the simpler case, these macros 
-  just return something like
-
-      SWIG_From_frag(bool)  => "SWIG_From_bool"
-      SWIG_From_dec(bool)   =>  SWIG_From_bool
-      SWIG_From(bool)       =>  SWIG_From_bool
-
-  But they are specialized for the different languages requirements,
-  such as perl or tcl that requires passing the interpreter pointer,
-  and also they can manage C++ ugly types, for example:
-  
-      SWIG_From_frag(std::complex<double>)  => "SWIG_From_std_complex_Sl_double_Sg_"
-      SWIG_From_dec(std::complex<double>)   =>  SWIG_From_std_complex_Sl_double_Sg_
-      SWIG_From(std::complex<double>)       =>  SWIG_From_std_complex_Sl_double_Sg_
-
-
-  Hence, to declare methods to use with typemaps, always use the
-  SWIG_From* macros. In the same way, the SWIG_AsVal* and SWIG_AsPtr*
-  set of macros are provided.
-    
-*/
-
-
-/* -----------------------------------------------------------------------------
- * Define the basic macros to 'normalize' the type fragments
- * ----------------------------------------------------------------------------- */
-
-#ifndef SWIG_AS_DECL_ARGS
-#define SWIG_AS_DECL_ARGS
-#endif
-
-#ifndef SWIG_FROM_DECL_ARGS
-#define SWIG_FROM_DECL_ARGS
-#endif
-
-#ifndef SWIG_AS_CALL_ARGS
-#define SWIG_AS_CALL_ARGS
-#endif
-
-#ifndef SWIG_FROM_CALL_ARGS
-#define SWIG_FROM_CALL_ARGS
-#endif
-
-#define %fragment_name(Name, Type...)     %string_name(Name) "_" {Type}
-
-#define SWIG_Traits_frag(Type...) %fragment_name(Traits, Type) 
-#define SWIG_AsPtr_frag(Type...)  %fragment_name(AsPtr, Type)	 
-#define SWIG_AsVal_frag(Type...)  %fragment_name(AsVal, Type)	 
-#define SWIG_From_frag(Type...)   %fragment_name(From, Type)	 
-
-#define SWIG_AsVal_name(Type...)  %symbol_name(AsVal, Type) 
-#define SWIG_AsPtr_name(Type...)  %symbol_name(AsPtr, Type) 
-#define SWIG_From_name(Type...)   %symbol_name(From, Type)  
-
-#define SWIG_AsVal_dec(Type...)   SWIG_AsVal_name(Type) SWIG_AS_DECL_ARGS
-#define SWIG_AsPtr_dec(Type...)   SWIG_AsPtr_name(Type) SWIG_AS_DECL_ARGS
-#define SWIG_From_dec(Type...)    SWIG_From_name(Type)  SWIG_FROM_DECL_ARGS 
-
-#define SWIG_AsVal(Type...)       SWIG_AsVal_name(Type) SWIG_AS_CALL_ARGS 
-#define SWIG_AsPtr(Type...)  	  SWIG_AsPtr_name(Type) SWIG_AS_CALL_ARGS 	 
-#define SWIG_From(Type...)   	  SWIG_From_name(Type)  SWIG_FROM_CALL_ARGS 
-
-/* ------------------------------------------------------------
- * common fragments 
- * ------------------------------------------------------------ */
-
-/* Default compiler options for gcc allow long_long but not LLONG_MAX. 
- * Define SWIG_NO_LLONG_MAX if this added limits support is not wanted. */
-%fragment("<limits.h>","header") %{
-#include <limits.h>
-#if !defined(SWIG_NO_LLONG_MAX)
-# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
-#   define LLONG_MAX __LONG_LONG_MAX__
-#   define LLONG_MIN (-LLONG_MAX - 1LL)
-#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
-# endif
-#endif
-%}
-
-%fragment("<math.h>","header") %{
-#include <math.h>
-%}
-
-%fragment("<wchar.h>","header") %{
-#include <wchar.h>
-#include <limits.h>
-#ifndef WCHAR_MIN
-#  define WCHAR_MIN 0
-#endif
-#ifndef WCHAR_MAX
-#  define WCHAR_MAX 65535
-#endif
-%}
-
-%fragment("<float.h>","header") %{
-#include <float.h>
-%}
-
-%fragment("<stdio.h>","header") %{
-#include <stdio.h>
-#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
-# ifndef snprintf
-#  define snprintf _snprintf
-# endif
-#endif
-%}
-
-%fragment("<stdlib.h>","header") %{
-#include <stdlib.h>
-#ifdef _MSC_VER
-# ifndef strtoull
-#  define strtoull _strtoui64
-# endif
-# ifndef strtoll
-#  define strtoll _strtoi64
-# endif
-#endif
-%}
-
-%fragment("<stddef.h>", "header")  %{
-  #include <stddef.h>
-%}
-
-%fragment("SWIG_isfinite","header",fragment="<math.h>,<float.h>") %{
-/* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */
-#ifndef SWIG_isfinite
-# if defined(isfinite)
-#  define SWIG_isfinite(X) (isfinite(X))
-# elif defined(_MSC_VER)
-#  define SWIG_isfinite(X) (_finite(X))
-# elif defined(__sun) && defined(__SVR4)
-#  include <ieeefp.h>
-#  define SWIG_isfinite(X) (finite(X))
-# endif
-#endif
-%}
-
-%fragment("SWIG_Float_Overflow_Check","header",fragment="<float.h>,SWIG_isfinite") %{
-/* Accept infinite as a valid float value unless we are unable to check if a value is finite */
-#ifdef SWIG_isfinite
-# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX) && SWIG_isfinite(X))
-#else
-# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX))
-#endif
-%}
-
-/* -----------------------------------------------------------------------------
- * special macros for fragments
- * ----------------------------------------------------------------------------- */
-
-/* Macros to derive numeric types */
-
-%define %numeric_type_from(Type, Base)
-%fragment(SWIG_From_frag(Type),"header",
-	  fragment=SWIG_From_frag(Base)) {
-SWIGINTERNINLINE SWIG_Object
-SWIG_From_dec(Type)(Type value)
-{    
-  return SWIG_From(Base)(value);
-}
-}
-%enddef
-
-%define %numeric_type_asval(Type, Base, Frag, OverflowCond)
-%fragment(SWIG_AsVal_frag(Type),"header",
-	  fragment=Frag,
-	  fragment=SWIG_AsVal_frag(Base)) {
-SWIGINTERN int
-SWIG_AsVal_dec(Type)(SWIG_Object obj, Type *val)
-{
-  Base v;
-  int res = SWIG_AsVal(Base)(obj, &v);
-  if (SWIG_IsOK(res)) {
-    if (OverflowCond) {
-      return SWIG_OverflowError;
-    } else {
-      if (val) *val = %numeric_cast(v, Type);
-    }
-  }  
-  return res;
-}
-}
-%enddef
-
-#define %numeric_signed_type_asval(Type, Base, Frag, Min, Max) \
-%numeric_type_asval(Type, Base, Frag, (v < Min || v > Max))
-
-#define %numeric_unsigned_type_asval(Type, Base, Frag, Max) \
-%numeric_type_asval(Type, Base, Frag, (v > Max))
-
-
-/* Macro for 'signed long' derived types */
-
-%define %numeric_slong(Type, Frag, Min, Max)
-%numeric_type_from(Type, long)
-%numeric_signed_type_asval(Type, long, Frag , Min, Max)
-%enddef
-
-/* Macro for 'unsigned long' derived types */
-
-%define %numeric_ulong(Type, Frag, Max)
-%numeric_type_from(Type, unsigned long)
-%numeric_unsigned_type_asval(Type, unsigned long, Frag, Max)
-%enddef
-
-
-/* Macro for floating point derived types (original macro) */
-
-%define %numeric_double(Type, Frag, Min, Max)
-%numeric_type_from(Type, double)
-%numeric_signed_type_asval(Type, double, Frag , Min, Max)
-%enddef
-
-/* Macro for floating point derived types */
-
-%define %numeric_float(Type, Frag, OverflowCond)
-%numeric_type_from(Type, double)
-%numeric_type_asval(Type, double, Frag, OverflowCond)
-%enddef
-
-
-/* Macros for missing fragments */
-
-%define %ensure_fragment(Fragment)
-%fragment(`Fragment`,"header") {
-%#error "SWIG language implementation must provide the Fragment fragment"
-}
-%enddef
-
-%define %ensure_type_fragments(Type)
-%fragment(SWIG_From_frag(Type),"header") {
-%#error "SWIG language implementation must provide a SWIG_From_frag(Type) fragment"
-}
-%fragment(SWIG_AsVal_frag(Type),"header") {
-%#error "SWIG language implementation must provide a SWIG_AsVal_frag(Type) fragment"
-}
-%enddef
diff --git a/share/swig/2.0.11/typemaps/implicit.swg b/share/swig/2.0.11/typemaps/implicit.swg
deleted file mode 100644
index 702fb52..0000000
--- a/share/swig/2.0.11/typemaps/implicit.swg
+++ /dev/null
@@ -1,208 +0,0 @@
-/*
-  The %implicit macro allows a SwigType (Class) to be accepted
-  as an input parameter and use its implicit constructors when needed.
-
-  For example:
-
-
-  %implicit(A, int, double, B);
-
-  %inline 
-  {
-    struct B { };  
-    struct A
-    {
-      int ii;
-      A(int i) { ii = 1; }
-      A(double d) { ii = 2; }
-      A(const B& b) { ii = 3; }
-    };
-  
-    int get(A a) { return a.ii; }
-  }
-
-  Here, you can call 'get' as 
-
-    get(1)    ==> get(A(1))
-    get(2.0)  ==> get(A(2.0))
-    get(B())  ==> get(A(B()))
-
-   and swig will construct an 'A' temporal variable using the
-   corresponding implicit constructor.
-
-
-  The plain implicit macro takes care of simple type list. If it doesn't
-  work because you are passing template types with commas, then use
-  the %implicit_{1,2,3} versions and/or the %arg macro.
-
-*/
-
-%define %implicit_type(Type...)
-%traits_swigtype(Type);
-%enddef
-
-%define %implicit_frag(Type...) ,fragment=SWIG_Traits_frag(Type) %enddef
-
-%define %implicit_code(Type...)
-{
-  Type _v;
-  int res = swig::asval<Type >(obj, &_v);  
-  if (SWIG_IsOK(res)) {
-    if (val) *val = new value_type(static_cast<const Type& >(_v));
-    return SWIG_AddNewMask(res);
-  }
-}
-%enddef
-
-/* implicit */
-
-%define %implicit(Type, ...)
-
-%formacro_1(%implicit_type,__VA_ARGS__);
-
-%fragment(SWIG_Traits_frag(Type),"header",
-	  fragment="StdTraits"
-          %formacro_1(%implicit_frag,__VA_ARGS__)) %{
-namespace swig {
-  template <>  struct traits<Type > {   
-    typedef pointer_category category;
-    static const char* type_name() { return "Type"; }
-  };
-   
-  template <> struct traits_asptr< Type > {
-  typedef Type value_type;
-  static int asptr(SWIG_Object obj, value_type **val) { 
-    Type *vptr;
-    static swig_type_info* desc = SWIG_TypeQuery("Type *");
-    int res = SWIG_ConvertPtr(obj, (void **)&vptr, desc, 0);
-    if (SWIG_IsOK(res)) {
-      if (val) *val = vptr;
-      return res;
-    } else {
-      %formacro_1(%implicit_code,__VA_ARGS__)
-    }
-    return SWIG_TypeError;
-  }
- };
-}
-%}
-
-%typemap_traits_ptr(%checkcode(POINTER),Type);
-%enddef
-
-/* implicit_1 */
-
-
-%define %implicit_1(Type, Imp1)
-%traits_swigtype(Imp1);
-
-%fragment(SWIG_Traits_frag(Type),"header",
-	  fragment="StdTraits",
-	  fragment=SWIG_Traits_frag(Imp1)) %{
-namespace swig {
-  template <>  struct traits< Type > {   
-    typedef pointer_category category;
-    static const char* type_name() { return "Type"; }
-  };
-   
-  template <> struct traits_asptr< Type > {   
-  typedef Type value_type;
-  static int asptr(SWIG_Object obj, value_type **val) { 
-    Type *vptr;
-    static swig_type_info* desc = SWIG_TypeQuery("Type *");
-    int res = SWIG_ConvertPtr(obj, (void **)&vptr, desc, 0);
-    if (SWIG_IsOK(res)) {
-      if (val) *val = vptr;
-      return res;
-    } else {
-      %implicit_code(Imp1);
-    }
-    return SWIG_TypeError;
-  }
- };
-}
-%}
-
-%typemap_traits_ptr(%checkcode(POINTER),Type);
-
-%enddef
-
-/* implicit_2 */
-
-%define %implicit_2(Type, Imp1, Imp2)
-%traits_swigtype(Imp1);
-%traits_swigtype(Imp2);
-
-%fragment(SWIG_Traits_frag(Type),"header",
-	  fragment="StdTraits",
-	  fragment=SWIG_Traits_frag(Imp1),
-	  fragment=SWIG_Traits_frag(Imp2)) %{
-namespace swig {
-  template <>  struct traits< Type > {   
-    typedef pointer_category category;
-    static const char* type_name() { return "Type"; }
-  };
-
-  template <> struct traits_asptr< Type > {   
-  typedef Type value_type;
-  static int asptr(SWIG_Object obj, value_type **val) { 
-    Type *vptr;
-    static swig_type_info* desc = SWIG_TypeQuery("Type *");
-    int res = SWIG_ConvertPtr(obj, (void **)&vptr, desc, 0);
-    if (SWIG_IsOK(res)) {
-      if (val) *val = vptr;
-      return SWIG_OLDOBJ;
-    } else {
-      %implicit_code(Imp1);
-      %implicit_code(Imp2);
-    }
-    return SWIG_TypeError;
-  }
- };
-}
-%}
-
-%typemap_traits_ptr(%checkcode(POINTER),Type);
-%enddef
-
-
-/* implicit_3 */
-
-%define %implicit_3(Type, Imp1, Imp2, Imp3)
-%traits_swigtype(Imp1);
-%traits_swigtype(Imp2);
-%traits_swigtype(Imp3);
-
-%fragment(SWIG_Traits_frag(Type),"header",
-	  fragment="StdTraits",
-	  fragment=SWIG_Traits_frag(Imp1),
-	  fragment=SWIG_Traits_frag(Imp2),
-	  fragment=SWIG_Traits_frag(Imp3)) %{
-namespace swig {
-  template <>  struct traits< Type > {   
-    typedef pointer_category category;
-    static const char* type_name() { return "Type"; }
-  };
-
-  template <> struct traits_asptr< Type > {   
-    typedef Type value_type;
-    static int asptr(SWIG_Object obj, value_type **val) { 
-    Type *vptr;
-    static swig_type_info* desc = SWIG_TypeQuery("Type *");
-    int res = SWIG_ConvertPtr(obj, (void **)&vptr, desc, 0);
-    if (SWIG_IsOK(res)) {
-      if (val) *val = vptr;
-      return res;
-    } else {
-      %implicit_code(Imp1);
-      %implicit_code(Imp2);
-      %implicit_code(Imp3);
-    }
-    return SWIG_TypeError;
-  }
- };
-}
-%}
-
-%typemap_traits_ptr(%checkcode(POINTER),Type);
-%enddef
diff --git a/share/swig/2.0.11/typemaps/primtypes.swg b/share/swig/2.0.11/typemaps/primtypes.swg
deleted file mode 100644
index 45632c3..0000000
--- a/share/swig/2.0.11/typemaps/primtypes.swg
+++ /dev/null
@@ -1,321 +0,0 @@
-/* ------------------------------------------------------------
- * Primitive type fragments and macros 
- * ------------------------------------------------------------ */
-
-/*
-  This file provide fragments and macros for the C/C++ primitive types. 
-
-  The file defines default fragments for the following types:
-
-    bool
-    signed char
-    unsigned char
-    signed wchar_t     // in C++
-    unsigned wchar_t   // in C++
-    short
-    unsigned short
-    int
-    unsigned int
-    float
-    size_t
-    ptrdiff_t
-
-  which can always be redefined in the swig target language if needed.
-  
-  The fragments for the following types, however, always need to be
-  defined in the target language:
-
-    long
-    unsigned long
-    long long
-    unsigned long long
-    double
- 
-  If they are not provided, an #error directive will appear in the
-  wrapped code.
-
-  --------------------------------------------------------------------
-  
-  This file provides the macro
-
-    %typemaps_primitive(CheckCode, Type)
-
-  which generates the typemaps for a primitive type with a given
-  checkcode. It is assumed that the primitive type is 'normalized' and
-  the corresponding SWIG_AsVal(Type) and SWIG_From(Type) methods are
-  provided via fragments.
-  
-   
-  The following auxiliary macros (explained with bash pseudo code) are
-  also defined:
-
-    %apply_ctypes(Macro)
-      for i in C Type
-      do
-        Macro($i)
-      done
-
-    %apply_cpptypes(Macro)
-      for i in C++ Type
-      do
-        Macro($i)
-      done
-
-    %apply_ctypes_2(Macro2)
-       for i in C Type
-       do
-         for j in C Type
-         do
-            Macro_2($i, $j)
-         done
-       done
-
-    %apply_cpptypes_2(Macro2)
-       for i in C++ Type
-       do
-         for j in C++ Type
-         do
-            Macro_2($i, $j)
-         done
-       done
-
-    %apply_checkctypes(Macro2)
-       for i in Check Type
-       do
-         Macro2(%checkcode($i), $i)
-       done
-
-*/
-
-
-/* ------------------------------------------------------------
- * Primitive type fragments 
- * ------------------------------------------------------------ */
-/* boolean */
-
-%fragment(SWIG_From_frag(bool),"header",fragment=SWIG_From_frag(long)) {
-SWIGINTERN SWIG_Object
-SWIG_From_dec(bool)(bool value)
-{    
-  return SWIG_From(long)(value ? 1 : 0);
-}
-}
-
-%fragment(SWIG_AsVal_frag(bool),"header",fragment=SWIG_AsVal_frag(long)) {
-SWIGINTERN int
-SWIG_AsVal_dec(bool)(SWIG_Object obj, bool *val)
-{
-  long v;
-  int res = SWIG_AsVal(long)(obj, val ? &v : 0);
-  if (SWIG_IsOK(res)) {    
-    if (val) *val = v ? true : false;
-    return res;
-  }  
-  return SWIG_TypeError;
-}
-}
-
-/* signed/unsigned char */
-
-%numeric_slong(signed char,     "<limits.h>", SCHAR_MIN, SCHAR_MAX)
-%numeric_ulong(unsigned char,   "<limits.h>", UCHAR_MAX)
-
-/* short/unsigned short */
-
-%numeric_slong(short,           "<limits.h>", SHRT_MIN, SHRT_MAX)
-%numeric_ulong(unsigned short,  "<limits.h>", USHRT_MAX)
-
-/* int/unsigned int */
-
-%numeric_slong(int,             "<limits.h>", INT_MIN, INT_MAX)
-%numeric_ulong(unsigned int,    "<limits.h>", UINT_MAX)
-
-/* signed/unsigned wchar_t */
-
-#ifdef __cplusplus
-%numeric_slong(signed wchar_t,   "<wchar.h>", WCHAR_MIN, WCHAR_MAX)
-%numeric_ulong(unsigned wchar_t, "<wchar.h>", UWCHAR_MAX)
-#endif
-
-/* float */
-
-%numeric_float(float,           "SWIG_Float_Overflow_Check", SWIG_Float_Overflow_Check(v))
-
-/* long/unsigned long */
-
-%ensure_type_fragments(long)
-%ensure_type_fragments(unsigned long)
-
-/* long long/unsigned long long */
-
-%ensure_type_fragments(long long)
-%ensure_type_fragments(unsigned long long)
-
-/* double */
-
-%ensure_type_fragments(double)
-
-/* size_t */
-
-%fragment(SWIG_From_frag(size_t),"header",fragment=SWIG_From_frag(unsigned long)) {
-SWIGINTERNINLINE SWIG_Object
-SWIG_From_dec(size_t)(size_t value)
-{    
-  return SWIG_From(unsigned long)(%numeric_cast(value, unsigned long));
-}
-}
-
-%fragment(SWIG_AsVal_frag(size_t),"header",fragment=SWIG_AsVal_frag(unsigned long)) {
-SWIGINTERNINLINE int
-SWIG_AsVal_dec(size_t)(SWIG_Object obj, size_t *val)
-{
-  unsigned long v;
-  int res = SWIG_AsVal(unsigned long)(obj, val ? &v : 0);
-  if (SWIG_IsOK(res) && val) *val = %numeric_cast(v, size_t);
-  return res;
-}
-}
-
-/* ptrdiff_t */
-
-%fragment(SWIG_From_frag(ptrdiff_t),"header",fragment=SWIG_From_frag(long)) {
-SWIGINTERNINLINE SWIG_Object
-SWIG_From_dec(ptrdiff_t)(ptrdiff_t value)
-{    
-  return SWIG_From(long)(%numeric_cast(value,long));
-}
-}
-
-%fragment(SWIG_AsVal_frag(ptrdiff_t),"header",fragment=SWIG_AsVal_frag(long)) {
-SWIGINTERNINLINE int
-SWIG_AsVal_dec(ptrdiff_t)(SWIG_Object obj, ptrdiff_t *val)
-{
-  long v;
-  int res = SWIG_AsVal(long)(obj, val ? &v : 0);
-  if (SWIG_IsOK(res) && val) *val = %numeric_cast(v, ptrdiff_t);
-  return res;
-}
-}
-
-
-%fragment("SWIG_CanCastAsInteger","header",
-	  fragment=SWIG_AsVal_frag(double),
-	  fragment="<float.h>",
-	  fragment="<math.h>") {
-SWIGINTERNINLINE int
-SWIG_CanCastAsInteger(double *d, double min, double max) {
-  double x = *d;
-  if ((min <= x && x <= max)) {
-   double fx = floor(x);
-   double cx = ceil(x);
-   double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
-   if ((errno == EDOM) || (errno == ERANGE)) {
-     errno = 0;
-   } else {
-     double summ, reps, diff;
-     if (rd < x) {
-       diff = x - rd;
-     } else if (rd > x) {
-       diff = rd - x;
-     } else {
-       return 1;
-     }
-     summ = rd + x;
-     reps = diff/summ;
-     if (reps < 8*DBL_EPSILON) {
-       *d = rd;
-       return 1;
-     }
-   }
-  }
-  return 0;
-}
-}
-
-/* ------------------------------------------------------------
- * Generate the typemaps for primitive type 
- * ------------------------------------------------------------ */
-
-#define %typemaps_primitive(Code, Type) %typemaps_asvalfromn(%arg(Code), Type)
-
-/* ------------------------------------------------------------
- * Primitive Type Macros
- * ------------------------------------------------------------ */
-
-/* useful macros to derive typemap declarations from primitive types */
-
-%define _apply_macro(macro, arg2, arg1...)
-#if #arg1 != ""
-macro(%arg(arg1),arg2);
-#else
-macro(arg2);
-#endif
-%enddef
-
-/* Apply macro to the C-types */
-%define %apply_ctypes(Macro, Arg2...)
-_apply_macro(Macro, bool               , Arg2);
-_apply_macro(Macro, signed char        , Arg2);
-_apply_macro(Macro, unsigned char      , Arg2);
-_apply_macro(Macro, short              , Arg2);
-_apply_macro(Macro, unsigned short     , Arg2);
-_apply_macro(Macro, int                , Arg2);
-_apply_macro(Macro, unsigned int       , Arg2);
-_apply_macro(Macro, long               , Arg2);
-_apply_macro(Macro, unsigned long      , Arg2);
-_apply_macro(Macro, long long          , Arg2);
-_apply_macro(Macro, unsigned long long , Arg2);
-_apply_macro(Macro, float              , Arg2);
-_apply_macro(Macro, double             , Arg2);
-_apply_macro(Macro, char               , Arg2);
-_apply_macro(Macro, wchar_t            , Arg2);
-_apply_macro(Macro, size_t             , Arg2);
-_apply_macro(Macro, ptrdiff_t          , Arg2);
-%enddef
-
-/* apply the Macro2(Type1, Type2) to all  C types  */
-#define %apply_ctypes_2(Macro2) %apply_ctypes(%apply_ctypes, Macro2)
-
-
-/* apply the Macro(Type) to all  C++ types  */
-%define %apply_cpptypes(Macro, Arg2...)
-%apply_ctypes(Macro, Arg2)
-_apply_macro(Macro, std::size_t, Arg2);
-_apply_macro(Macro, std::ptrdiff_t, Arg2);
-_apply_macro(Macro, std::string, Arg2);
-_apply_macro(Macro, std::wstring, Arg2);
-_apply_macro(Macro, std::complex<float>, Arg2);
-_apply_macro(Macro, std::complex<double>, Arg2);
-%enddef
-
-/* apply the Macro2(Type1, Type2) to all  C++ types  */
-#define %apply_cpptypes_2(Macro2) %apply_cpptypes(%apply_cpptypes, Macro2)
-
-/* apply the Macro2(CheckCode,Type) to all  Checked Types */
-%define %apply_checkctypes(Macro2)
-Macro2(%checkcode(BOOL),    bool);
-Macro2(%checkcode(INT8),    signed char);
-Macro2(%checkcode(UINT8),   unsigned char);
-Macro2(%checkcode(INT16),   short);
-Macro2(%checkcode(UINT16),  unsigned short);
-Macro2(%checkcode(INT32),   int);
-Macro2(%checkcode(UINT32),  unsigned int);
-Macro2(%checkcode(INT64),   long);
-Macro2(%checkcode(UINT64),  unsigned long);
-Macro2(%checkcode(INT128),  long long);
-Macro2(%checkcode(UINT128), unsigned long long);
-Macro2(%checkcode(FLOAT),   float);
-Macro2(%checkcode(DOUBLE),  double);
-Macro2(%checkcode(CHAR),    char);
-Macro2(%checkcode(UNICHAR), wchar_t);
-Macro2(%checkcode(SIZE),    size_t);
-Macro2(%checkcode(PTRDIFF), ptrdiff_t);
-%enddef
-
-
-/* ------------------------------------------------------------
- * Generate the typemaps for all the primitive types with checkcode
- * ------------------------------------------------------------ */
-
-%apply_checkctypes(%typemaps_primitive);
-
diff --git a/share/swig/2.0.11/typemaps/std_except.swg b/share/swig/2.0.11/typemaps/std_except.swg
deleted file mode 100644
index cb5ed30..0000000
--- a/share/swig/2.0.11/typemaps/std_except.swg
+++ /dev/null
@@ -1,36 +0,0 @@
-%include <typemaps/exception.swg>
-
-/* 
-   Mark all of std exception classes as "exception classes" via
-   the "exceptionclass" feature.
-   
-   If needed, you can disable it by using %noexceptionclass.
-*/
-
-%define %std_exception_map(Exception, Code)
-  %exceptionclass  Exception; 
-#if !defined(SWIG_STD_EXCEPTIONS_AS_CLASSES)
-  %typemap(throws,noblock=1) Exception {
-    SWIG_exception_fail(Code, $1.what());
-  }
-  %ignore Exception;
-  struct Exception {
-  };
-#endif
-%enddef
-
-namespace std {
-  %std_exception_map(bad_exception,      SWIG_SystemError);
-  %std_exception_map(domain_error,       SWIG_ValueError);
-  %std_exception_map(exception,          SWIG_SystemError);
-  %std_exception_map(invalid_argument,   SWIG_ValueError);
-  %std_exception_map(length_error,       SWIG_IndexError);
-  %std_exception_map(logic_error,        SWIG_RuntimeError);
-  %std_exception_map(out_of_range,       SWIG_IndexError);
-  %std_exception_map(overflow_error,     SWIG_OverflowError);
-  %std_exception_map(range_error,        SWIG_OverflowError);
-  %std_exception_map(runtime_error,      SWIG_RuntimeError);
-  %std_exception_map(underflow_error,    SWIG_OverflowError);
-}
-
-%include <std/std_except.i>
diff --git a/share/swig/2.0.11/typemaps/std_string.swg b/share/swig/2.0.11/typemaps/std_string.swg
deleted file mode 100644
index 691bf2c..0000000
--- a/share/swig/2.0.11/typemaps/std_string.swg
+++ /dev/null
@@ -1,27 +0,0 @@
-//
-// String
-//
-
-
-#ifndef SWIG_STD_BASIC_STRING
-#define SWIG_STD_STRING
-
-%include <typemaps/std_strings.swg>
-
-%{
-#include <string>
-%}
-  
-namespace std
-{
-  %naturalvar string;
-  class string;
-}
-
-%typemaps_std_string(std::string, char, SWIG_AsCharPtrAndSize, SWIG_FromCharPtrAndSize, %checkcode(STDSTRING));
-
-#else
-
-%include <std/std_string.i>
-
-#endif
diff --git a/share/swig/2.0.11/typemaps/std_wstring.swg b/share/swig/2.0.11/typemaps/std_wstring.swg
deleted file mode 100644
index 670685f..0000000
--- a/share/swig/2.0.11/typemaps/std_wstring.swg
+++ /dev/null
@@ -1,26 +0,0 @@
-%include <typemaps/wstring.swg>
-
-#ifndef SWIG_STD_BASIC_STRING
-#define SWIG_STD_WSTRING
-
-%include <typemaps/std_strings.swg>
-
-%{
-#include <cwchar>
-#include <string>
-%}
-
-namespace std
-{
-  %naturalvar wstring;
-  class wstring;
-}
-
-%typemaps_std_string(std::wstring, wchar_t, SWIG_AsWCharPtrAndSize, SWIG_FromWCharPtrAndSize, %checkcode(STDUNISTRING));
-
-
-#else
-
-%include <std/std_wstring.i>
-
-#endif
diff --git a/share/swig/2.0.11/typemaps/string.swg b/share/swig/2.0.11/typemaps/string.swg
deleted file mode 100644
index 279ee2a..0000000
--- a/share/swig/2.0.11/typemaps/string.swg
+++ /dev/null
@@ -1,24 +0,0 @@
-%ensure_fragment(SWIG_AsCharPtrAndSize)
-%ensure_fragment(SWIG_FromCharPtrAndSize)
-
-%types(char *);
-
-%fragment("SWIG_pchar_descriptor","header") {
-SWIGINTERN swig_type_info*
-SWIG_pchar_descriptor(void)
-{
-  static int init = 0;
-  static swig_type_info* info = 0;
-  if (!init) {
-    info = SWIG_TypeQuery("_p_char");
-    init = 1;
-  }
-  return info;
-}
-}
-
-
-%include <typemaps/strings.swg>
-%typemaps_string(%checkcode(STRING), %checkcode(CHAR),
-		 char, Char, SWIG_AsCharPtrAndSize, SWIG_FromCharPtrAndSize, strlen,
-		"<limits.h>", CHAR_MIN, CHAR_MAX)
diff --git a/share/swig/2.0.11/typemaps/strings.swg b/share/swig/2.0.11/typemaps/strings.swg
deleted file mode 100644
index 55e9d2b..0000000
--- a/share/swig/2.0.11/typemaps/strings.swg
+++ /dev/null
@@ -1,638 +0,0 @@
-//
-// Use the macro SWIG_PRESERVE_CARRAY_SIZE if you prefer to preserve
-// the size of char arrays, ie
-//  ------------------------------------------
-//       C Side             =>   Language Side
-//  ------------------------------------------
-//   char name[5] = "hola"  =>   'hola\0'
-//
-// the default behaviour is 
-//
-//   char name[5] = "hola"  =>   'hola'
-//
-//
-//#define SWIG_PRESERVE_CARRAY_SIZE
-
-/* ------------------------------------------------------------
- *  String typemaps for type Char (char or wchar_t)
- * ------------------------------------------------------------ */
-
-%define %_typemap_string(StringCode, 
-			 Char,
-			 SWIG_AsCharPtrAndSize,
-			 SWIG_FromCharPtrAndSize,
-			 SWIG_CharPtrLen,
-			 SWIG_AsCharPtr,
-			 SWIG_FromCharPtr,
-			 SWIG_AsCharArray,
-                         SWIG_NewCopyCharArray,
-                         SWIG_DeleteCharArray)
-
-/* in */
-
-%typemap(in,noblock=1,fragment=#SWIG_AsCharPtr) 
-  Char * (int res, Char *buf = 0, int alloc = 0),
-  const Char * (int res, Char *buf = 0, int alloc = 0) {
-  res = SWIG_AsCharPtr($input, &buf, &alloc);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res,"$type",$symname, $argnum);
-  }
-  $1 = %reinterpret_cast(buf, $1_ltype);
-}
-%typemap(freearg,noblock=1,match="in") Char *, const Char * {
-  if (alloc$argnum == SWIG_NEWOBJ) SWIG_DeleteCharArray(buf$argnum);
-}
-
-%typemap(in,noblock=1,fragment=#SWIG_AsCharPtr) Char const*& (int res, Char *buf = 0, int alloc = 0) {
-  res = SWIG_AsCharPtr($input, &buf, &alloc);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res,"$type",$symname, $argnum);
-  }
-  $1 = &buf;
-}    
-%typemap(freearg, noblock=1,match="in") Char const*& {
-  if (alloc$argnum == SWIG_NEWOBJ) SWIG_DeleteCharArray(buf$argnum);
-}
-
-/* out */
-
-%typemap(out,noblock=1,fragment=#SWIG_FromCharPtr) Char *, const Char * {
-  %set_output(SWIG_FromCharPtr((const Char *)$1));
-}
-
-
-%typemap(out,noblock=1,fragment=#SWIG_FromCharPtr) Char const*& {
-  %set_output(SWIG_FromCharPtr(*$1));
-}
-
-%typemap(newfree,noblock=1) Char * {
-  SWIG_DeleteCharArray($1);
-}
-
-/* varin */
-
-%typemap(varin,fragment=#SWIG_AsCharPtrAndSize) Char * {
-  Char *cptr = 0; size_t csize = 0; int alloc = SWIG_NEWOBJ;
-  int res = SWIG_AsCharPtrAndSize($input, &cptr, &csize, &alloc);
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res,"$type","$name");
-  }
-  if ($1) SWIG_DeleteCharArray($1);
-  if (alloc == SWIG_NEWOBJ) {
-    $1 = cptr;
-  } else {
-    $1 = csize ? ($1_type)SWIG_NewCopyCharArray(cptr, csize, Char) : 0;
-  }
-}
-
-%typemap(varin,fragment=#SWIG_AsCharPtrAndSize,warning=SWIGWARN_TYPEMAP_CHARLEAK_MSG) const Char * {
-  Char *cptr = 0; size_t csize = 0; int alloc = SWIG_NEWOBJ;
-  int res = SWIG_AsCharPtrAndSize($input, &cptr, &csize, &alloc);
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res, "$type", "$name");
-  }
-  if (alloc == SWIG_NEWOBJ) {
-    $1 = cptr;
-  } else {
-    $1 = csize ? ($1_type)SWIG_NewCopyCharArray(cptr, csize, Char) : 0;
-  }
-}
-
-/* varout */
-
-%typemap(varout,noblock=1,fragment=#SWIG_FromCharPtr) Char *, const Char * {
-  %set_varoutput(SWIG_FromCharPtr($1));
-}
-
-/* memberin */
-
-%typemap(memberin,noblock=1) Char * {
-  if ($1) SWIG_DeleteCharArray($1);
-  if ($input) {
-    size_t size = SWIG_CharPtrLen(%reinterpret_cast($input, const Char *)) + 1;
-    $1 = ($1_type)SWIG_NewCopyCharArray(%reinterpret_cast($input, const Char *), size, Char);
-  } else {
-    $1 = 0;
-  }
-}
-
-%typemap(memberin,noblock=1,warning=SWIGWARN_TYPEMAP_CHARLEAK_MSG) const Char * {
-  if ($input) {
-    size_t size = SWIG_CharPtrLen(%reinterpret_cast(%reinterpret_cast($input, const Char *), const Char *)) + 1;
-    $1 = ($1_type)SWIG_NewCopyCharArray($input, size, Char);
-  } else {
-    $1 = 0;
-  }
-}
-
-/* globalin */
-
-%typemap(globalin,noblock=1) Char * {
-  if ($1) SWIG_DeleteCharArray($1);
-  if ($input) {
-    size_t size = SWIG_CharPtrLen(%reinterpret_cast(%reinterpret_cast($input, const Char *), const Char *)) + 1;
-    $1 = ($1_type)SWIG_NewCopyCharArray($input, size, Char);
-  } else {
-    $1 = 0;
-  }
-}
-
-%typemap(globalin,noblock=1,warning=SWIGWARN_TYPEMAP_CHARLEAK_MSG) const Char * {
-  if ($input) {
-    size_t size = SWIG_CharPtrLen($input) + 1;
-    $1 = ($1_type)SWIG_NewCopyCharArray($input, size, Char);
-  } else {
-    $1 = 0;
-  }
-}
-
-/* constant */
-
-%typemap(constcode,noblock=1,fragment=#SWIG_FromCharPtr)
-  Char *, Char const*, Char * const, Char const* const {
-  %set_constant("$symname", SWIG_FromCharPtr($value));
-}
-
-
-#if defined(SWIG_DIRECTOR_TYPEMAPS)
-
-/* directorin */
-
-%typemap(directorin,noblock=1,fragment=#SWIG_FromCharPtr)
-  Char *, Char const*, Char *const, Char const *const, 
-  Char const *&, Char *const &, Char const *const & {
-  $input = SWIG_FromCharPtr((const Char *)$1);
-}
-
-
-/* directorout */
-
-%typemap(directorout,noblock=1,fragment=#SWIG_AsCharPtr,warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) Char * (int res, Char *buf = 0, int alloc = SWIG_NEWOBJ) {
-  res = SWIG_AsCharPtr($input, &buf, &alloc);
-  if (!SWIG_IsOK(res)) {
-    %dirout_fail(res, "$type");
-  }
-  if (alloc == SWIG_NEWOBJ) {
-    swig_acquire_ownership_array(buf);
-  }
-  $result = %reinterpret_cast(buf, $1_ltype);
-}
-%typemap(directorfree,noblock=1) Char *
-{
-  if (director) {
-    director->swig_release_ownership(%as_voidptr($input));
-  }
-}
-
-
-%typemap(directorout,noblock=1,fragment=#SWIG_AsCharPtr,warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) Char *const& (int res, Char *buf = 0, int alloc = SWIG_NEWOBJ), Char const*const& (int res, Char *buf = 0, int alloc = SWIG_NEWOBJ) { 
-  res = SWIG_AsCharPtr($input, &buf, &alloc);
-  if (!SWIG_IsOK(res)) {
-    %dirout_fail(res, "$type");
-  }
-  static $*1_ltype tmp = buf;
-  $result = &tmp;
-  if (alloc == SWIG_NEWOBJ) {
-    swig_acquire_ownership_array(buf);
-  }
-}
-%typemap(directorfree,noblock=1)
-  Char * const&, Char const* const& {
-  if (director) {
-    director->swig_release_ownership(%as_voidptr(*$input));
-  }
-}
-
-#endif /* SWIG_DIRECTOR_TYPEMAPS */
-
-/* typecheck */
-
-%typemap(typecheck,noblock=1,precedence=StringCode,
-	 fragment=#SWIG_AsCharPtr) Char *, const Char *, Char const*& {
-  int res = SWIG_AsCharPtr($input, 0, 0);
-  $1 = SWIG_CheckState(res);
-}
-
-
-/* throws */
-
-%typemap(throws,noblock=1,fragment=#SWIG_FromCharPtr) Char * {
-  %raise(SWIG_FromCharPtr($1), "$type", 0);
-}
-
-
-/* ------------------------------------------------------------
- *  Unknown size const Character array Char[ANY] handling
- * ------------------------------------------------------------ */
-
-%apply Char * { Char [] };
-%apply const Char * { const Char [] };
-
-%typemap(varin,noblock=1,warning="462:Unable to set variable of type Char []") Char []
-{
-  %variable_fail(SWIG_AttributeError, "$type", "read-only $name");
-}
-
-
-/* ------------------------------------------------------------
- *  Fixed size Character array Char[ANY] handling
- * ------------------------------------------------------------ */
-
-/*  memberin and globalin typemaps  */
-
-%typemap(memberin,noblock=1) Char [ANY]
-{
-  if ($input) memcpy($1,$input,$1_dim0*sizeof(Char));
-  else memset($1,0,$1_dim0*sizeof(Char));
-}
-
-%typemap(globalin,noblock=1) Char [ANY]
-{
-  if ($input) memcpy($1,$input,$1_dim0*sizeof(Char));
-  else memset($1,0,$1_dim0*sizeof(Char));
-}
-
-/* in */
-
-%typemap(in,noblock=1,fragment=#SWIG_AsCharArray)
-  Char [ANY] (Char temp[$1_dim0], int res), 
-  const Char [ANY](Char temp[$1_dim0], int res)
-{  
-  res = SWIG_AsCharArray($input, temp, $1_dim0);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res,"$type",$symname, $argnum);
-  }
-  $1 = %reinterpret_cast(temp, $1_ltype);
-}
-%typemap(freearg) Char [ANY], const Char [ANY] "";
-
-%typemap(in,noblock=1,fragment=#SWIG_AsCharArray) const Char (&)[ANY] (Char temp[$1_dim0], int res)
-{  
-  res = SWIG_AsCharArray($input, temp, $1_dim0);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res,"$type",$symname, $argnum);
-  }
-  $1 = &temp;
-}
-%typemap(freearg) const Char (&)[ANY] "";
-
-%typemap(out,fragment=#SWIG_FromCharPtrAndSize)
-  Char [ANY], const Char[ANY] 
-{
-  size_t size = $1_dim0;
-%#ifndef SWIG_PRESERVE_CARRAY_SIZE
-  while (size && ($1[size - 1] == '\0')) --size;
-%#endif
-   %set_output(SWIG_FromCharPtrAndSize($1, size));
-}
-
-/* varin */
-
-%typemap(varin,fragment=#SWIG_AsCharArray) Char [ANY]
-{
-  int res = SWIG_AsCharArray($input, $1, $1_dim0);
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res, "$type", "$name");
-  }
-}
-
-/* varout */
-
-%typemap(varout,noblock=1,fragment=#SWIG_FromCharPtrAndSize)
-  Char [ANY], const Char [ANY] {
-  size_t size = $1_dim0;
-%#ifndef SWIG_PRESERVE_CARRAY_SIZE
-  while (size && ($1[size - 1] == '\0')) --size;
-%#endif
-  %set_varoutput(SWIG_FromCharPtrAndSize($1, size));
-}
-
-/* constant */
-
-%typemap(constcode,fragment=#SWIG_FromCharPtrAndSize)
-  Char [ANY], const Char [ANY]
-{
-  size_t size = $value_dim0;
-%#ifndef SWIG_PRESERVE_CARRAY_SIZE
-  while (size && ($value[size - 1] == '\0')) --size;
-%#endif
-  %set_constant("$symname", SWIG_FromCharPtrAndSize($value,size));
-}
-
-
-#if defined(SWIG_DIRECTOR_TYPEMAPS)
-
-/* directorin */
-%typemap(directorin,fragment=#SWIG_FromCharPtrAndSize)
-  Char [ANY], const Char [ANY] 
-{
-  size_t size = $1_dim0;
-%#ifndef SWIG_PRESERVE_CARRAY_SIZE
-  while (size && ($1[size - 1] == '\0')) --size;
-%#endif
-  $input = SWIG_FromCharPtrAndSize($1, size);
-}
-
-/* directorout */
-
-%typemap(directorout,noblock=1,fragment=#SWIG_AsCharArray)
-  Char [ANY] (Char temp[$result_dim0]),
-  const Char [ANY] (Char temp[$result_dim0], int res)
-{ 
-  res = SWIG_AsCharArray($input, temp, $result_dim0);
-  if (!SWIG_IsOK(res)) {
-    %dirout_fail(res, "$type");
-  }
-  $result = temp;
-}
-
-#endif /* SWIG_DIRECTOR_TYPEMAPS */
-
-/* typecheck */
-
-%typemap(typecheck,noblock=1,precedence=StringCode,
-	 fragment=#SWIG_AsCharArray)  
-  Char [ANY], const Char[ANY] {
-  int res = SWIG_AsCharArray($input, (Char *)0, $1_dim0);
-  $1 = SWIG_CheckState(res);
-}
-
-
-/* throws */
-
-%typemap(throws,fragment=#SWIG_FromCharPtrAndSize)
-  Char [ANY], const Char[ANY]
-{
-  size_t size = $1_dim0;
-%#ifndef SWIG_PRESERVE_CARRAY_SIZE
-  while (size && ($1[size - 1] == '\0')) --size;
-%#endif
-  %raise(SWIG_FromCharPtrAndSize($1, size), "$type", 0); 
-}
-
-/* -------------------------------------------------------------------
- * --- Really fix size Char arrays, including '\0'chars at the end ---
- * ------------------------------------------------------------------- */
-
-%typemap(varout,noblock=1,fragment=#SWIG_FromCharPtrAndSize)
-  Char FIXSIZE[ANY], const Char FIXSIZE[ANY]
-{
-  %set_varoutput(SWIG_FromCharPtrAndSize($1, $1_dim0));
-}
-
-%typemap(out,noblock=1,fragment=#SWIG_FromCharPtrAndSize)
-  Char FIXSIZE[ANY], const Char FIXSIZE[ANY]
-{
-  %set_output(SWIG_FromCharPtrAndSize($1, $1_dim0));
-}
-
-#if defined(SWIG_DIRECTOR_TYPEMAPS)
-
-%typemap(directorin,noblock=1,fragment=#SWIG_FromCharPtrAndSize)
-  Char FIXSIZE[ANY], const Char FIXSIZE[ANY]
-{
-  $input = SWIG_FromCharPtrAndSize($1, $1_dim0);
-}
-
-#endif /* SWIG_DIRECTOR_TYPEMAPS */
-
-%typemap(throws,noblock=1,fragment=#SWIG_FromCharPtrAndSize)
-  Char FIXSIZE[ANY], const Char FIXSIZE[ANY] {
-  %raise(SWIG_FromCharPtrAndSize($1, $1_dim0), "$type", 0); 
-}
-
-/* ------------------------------------------------------------
- * --- String & length ---
- * ------------------------------------------------------------ */
-
-/* Here len doesn't include the '0' terminator */
-%typemap(in,noblock=1,fragment=#SWIG_AsCharPtrAndSize) 
-  (Char *STRING, size_t LENGTH) (int res, Char *buf = 0, size_t size = 0, int alloc = 0),
-  (const Char *STRING, size_t LENGTH) (int res, Char *buf = 0, size_t size = 0, int alloc = 0)
-{
-  res = SWIG_AsCharPtrAndSize($input, &buf, &size, &alloc);
-  if (!SWIG_IsOK(res)) { 
-    %argument_fail(res,"$type",$symname, $argnum);
-  }  
-  $1 = %reinterpret_cast(buf, $1_ltype);
-  $2 = %numeric_cast(size - 1, $2_ltype);
-}
-%typemap(freearg,noblock=1,match="in") (Char *STRING, size_t LENGTH) {
-  if (alloc$argnum == SWIG_NEWOBJ) SWIG_DeleteCharArray(buf$argnum);
-}
-/* old 'int' form */
-%typemap(in) (Char *STRING, int LENGTH) = (Char *STRING, size_t LENGTH);
-%typemap(freearg) (Char *STRING, int LENGTH) = (Char *STRING, size_t LENGTH);
-
-
-/* Here size includes the '0' terminator */
-%typemap(in,noblock=1,fragment=#SWIG_AsCharPtrAndSize)
-  (Char *STRING, size_t SIZE) (int res, Char *buf = 0, size_t size = 0, int alloc = 0),
-  (const Char *STRING, size_t SIZE) (int res, Char *buf = 0, size_t size = 0, int alloc = 0)
-{
-  res = SWIG_AsCharPtrAndSize($input, &buf, &size, &alloc);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res,"$type",$symname, $argnum);
-  }
-  $1 = %reinterpret_cast(buf, $1_ltype);
-  $2 = %numeric_cast(size, $2_ltype);
-}
-%typemap(freearg,noblock=1,match="in") (Char *STRING, size_t SIZE) {
-  if (alloc$argnum == SWIG_NEWOBJ) SWIG_DeleteCharArray(buf$argnum);
-}
-/* old 'int' form */
-%typemap(in) (Char *STRING, int SIZE) = (Char *STRING, size_t SIZE);
-%typemap(freearg) (Char *STRING, int SIZE) = (Char *STRING, size_t SIZE);
-
-
-/* reverse order versions */
-
-/* Here len doesn't include the '0' terminator */
-%typemap(in,noblock=1,fragment=#SWIG_AsCharPtrAndSize) 
-  (size_t LENGTH, Char *STRING) (int res, Char *buf = 0, size_t size = 0, int alloc = 0),
-  (size_t LENGTH, const Char *STRING) (int res, Char *buf = 0, size_t size = 0, int alloc = 0)
-{
-  res = SWIG_AsCharPtrAndSize($input, &buf, &size, &alloc);
-  if (!SWIG_IsOK(res)) { 
-    %argument_fail(res,"$type",$symname, $argnum);
-  }  
-  $2 = %reinterpret_cast(buf, $2_ltype) ;
-  $1 = %numeric_cast(size - 1, $1_ltype) ;
-}
-%typemap(freearg, noblock=1, match="in") (size_t LENGTH, Char *STRING) {
-  if (alloc$argnum == SWIG_NEWOBJ) SWIG_DeleteCharArray(buf$argnum);
-}
-/* old 'int' form */
-%typemap(in) (int LENGTH, Char *STRING) = (size_t LENGTH, Char *STRING);
-%typemap(freearg) (int LENGTH, Char *STRING) = (size_t LENGTH, Char *STRING);
-
-/* Here size includes the '0' terminator */
-%typemap(in,noblock=1,fragment=#SWIG_AsCharPtrAndSize)
-  (size_t SIZE, Char *STRING) (int res, Char *buf = 0, size_t size = 0, int alloc = 0),
-  (size_t SIZE, const Char *STRING) (int res, Char *buf = 0, size_t size = 0, int alloc = 0)
-{
-  res = SWIG_AsCharPtrAndSize($input, &buf, &size, &alloc);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type",$symname, $argnum);
-  }
-  $2 = %reinterpret_cast(buf, $2_ltype) ;
-  $1 = %numeric_cast(size, $1_ltype) ;
-}
-%typemap(freearg, noblock=1, match="in") (size_t SIZE, Char *STRING) {
-  if (alloc$argnum == SWIG_NEWOBJ) SWIG_DeleteCharArray(buf$argnum);
-}
-/* old 'int' form */
-%typemap(in) (int SIZE, Char *STRING) = (size_t SIZE, Char *STRING);
-%typemap(freearg) (int SIZE, Char *STRING) = (size_t SIZE, Char *STRING);
-
-
-%enddef
-
-
-/* ------------------------------------------------------------
- * --- String fragment methods ---
- * ------------------------------------------------------------ */
-
-
-%define %_typemap2_string(StringCode, CharCode,
-			 Char, CharName,
-			 SWIG_AsCharPtrAndSize,
-			 SWIG_FromCharPtrAndSize,
-			 SWIG_CharPtrLen,
-			 SWIG_NewCopyCharArray,
-			 SWIG_DeleteCharArray,
-			 FragLimits, CHAR_MIN, CHAR_MAX)
-  
-%fragment("SWIG_From"#CharName"Ptr","header",fragment=#SWIG_FromCharPtrAndSize) {
-SWIGINTERNINLINE SWIG_Object 
-SWIG_From##CharName##Ptr(const Char *cptr)
-{ 
-  return SWIG_FromCharPtrAndSize(cptr, (cptr ? SWIG_CharPtrLen(cptr) : 0));
-}
-}
-
-%fragment("SWIG_From"#CharName"Array","header",fragment=#SWIG_FromCharPtrAndSize) {
-SWIGINTERNINLINE SWIG_Object 
-SWIG_From##CharName##Array(const Char *cptr, size_t size)
-{ 
-  return SWIG_FromCharPtrAndSize(cptr, size);
-}
-}
-
-%fragment("SWIG_As" #CharName "Ptr","header",fragment=#SWIG_AsCharPtrAndSize) {
-%define_as(SWIG_As##CharName##Ptr(obj, val, alloc), SWIG_AsCharPtrAndSize(obj, val, NULL, alloc))
-}
-
-%fragment("SWIG_As" #CharName "Array","header",fragment=#SWIG_AsCharPtrAndSize) {
-SWIGINTERN int
-SWIG_As##CharName##Array(SWIG_Object obj, Char *val, size_t size)
-{ 
-  Char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
-  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
-  if (SWIG_IsOK(res)) {
-    if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
-    if (csize <= size) {
-      if (val) {
-	if (csize) memcpy(val, cptr, csize*sizeof(Char));
-	if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(Char));
-      }
-      if (alloc == SWIG_NEWOBJ) {
-	SWIG_DeleteCharArray(cptr);
-	res = SWIG_DelNewMask(res);
-      }      
-      return res;
-    }
-    if (alloc == SWIG_NEWOBJ) SWIG_DeleteCharArray(cptr);
-  }
-  return SWIG_TypeError;
-}
-}
-
-/* Char */
-
-%fragment(SWIG_From_frag(Char),"header",fragment=#SWIG_FromCharPtrAndSize) {
-SWIGINTERNINLINE SWIG_Object
-SWIG_From_dec(Char)(Char c) 
-{ 
-  return SWIG_FromCharPtrAndSize(&c,1);
-}
-}
-
-%fragment(SWIG_AsVal_frag(Char),"header",
-	  fragment="SWIG_As"#CharName"Array",
-	  fragment=FragLimits,
-	  fragment=SWIG_AsVal_frag(long)) {
-SWIGINTERN int
-SWIG_AsVal_dec(Char)(SWIG_Object obj, Char *val)
-{    
-  int res = SWIG_As##CharName##Array(obj, val, 1);
-  if (!SWIG_IsOK(res)) {
-    long v;
-    res = SWIG_AddCast(SWIG_AsVal(long)(obj, &v));
-    if (SWIG_IsOK(res)) {
-      if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
-	if (val) *val = %numeric_cast(v, Char);
-      } else {
-	res = SWIG_OverflowError;
-      }
-    }
-  }
-  return res;
-}
-}
-
-%_typemap_string(StringCode, 
-		 Char,
-		 SWIG_AsCharPtrAndSize,
-		 SWIG_FromCharPtrAndSize,
-		 SWIG_CharPtrLen,
-		 SWIG_As##CharName##Ptr,
-		 SWIG_From##CharName##Ptr,
-		 SWIG_As##CharName##Array,
-		 SWIG_NewCopyCharArray,
-		 SWIG_DeleteCharArray)
-
-%enddef
-
-
-/* ------------------------------------------------------------
- *  String typemaps and fragments, with default allocators
- * ------------------------------------------------------------ */
-
-%define %typemaps_string(StringCode, CharCode,
-			 Char, CharName,
-			 SWIG_AsCharPtrAndSize,
-			 SWIG_FromCharPtrAndSize,
-			 SWIG_CharPtrLen,
-			 FragLimits, CHAR_MIN, CHAR_MAX)
-%_typemap2_string(StringCode, CharCode,
-		  Char, CharName,
-		  SWIG_AsCharPtrAndSize,
-		  SWIG_FromCharPtrAndSize,
-		  SWIG_CharPtrLen,
-		  %new_copy_array,
-		  %delete_array,
-		  FragLimits, CHAR_MIN, CHAR_MAX)
-%enddef
-
-/* ------------------------------------------------------------
- *  String typemaps and fragments, with custom allocators
- * ------------------------------------------------------------ */
-
-%define %typemaps_string_alloc(StringCode, CharCode,
-			       Char, CharName,
-			       SWIG_AsCharPtrAndSize,
-			       SWIG_FromCharPtrAndSize,
-			       SWIG_CharPtrLen,
-			       SWIG_NewCopyCharArray,
-			       SWIG_DeleteCharArray,
-			       FragLimits, CHAR_MIN, CHAR_MAX)
-%_typemap2_string(StringCode, CharCode,
-		  Char, CharName,
-		  SWIG_AsCharPtrAndSize,
-		  SWIG_FromCharPtrAndSize,
-		  SWIG_CharPtrLen,
-		  SWIG_NewCopyCharArray,
-		  SWIG_DeleteCharArray,
-		  FragLimits, CHAR_MIN, CHAR_MAX)
-%enddef
diff --git a/share/swig/2.0.11/typemaps/swigmacros.swg b/share/swig/2.0.11/typemaps/swigmacros.swg
deleted file mode 100644
index c9b42fa..0000000
--- a/share/swig/2.0.11/typemaps/swigmacros.swg
+++ /dev/null
@@ -1,245 +0,0 @@
-/* -----------------------------------------------------------------------------
- * SWIG API. Portion only visible from SWIG
- * ----------------------------------------------------------------------------- */
-/*
-  This file implements the internal macros of the 'SWIG API', which
-  are useful to implement all the SWIG target languges.
-
-  Basic preprocessor macros:
-  --------------------------
-
-    %arg(Arg)               Safe argument wrap
-    %str(Arg)               Stringtify the argument
-    %begin_block            Begin a execution block
-    %end_block              End a execution block
-    %block(Block)           Execute Block as a excecution block
-    %define_as(Def, Val)    Define 'Def' as 'Val', expanding Def and Val first
-    %ifcplusplus(V1, V2)    if C++ Mode; then V1; else V2; fi
-
-
-  Casting Operations:
-  -------------------
-
-  SWIG provides the following casting macros, which implement the
-  corresponding C++ casting operations:
-
-    %const_cast(a, Type)         const_cast<Type >(a)
-    %static_cast(a, Type)      	 static_cast<Type >(a)
-    %reinterpret_cast(a, Type) 	 reinterpret_cast<Type >(a)
-    %numeric_cast(a, Type)     	 static_cast<Type >(a)
-    %as_voidptr(a)            	 const_cast<void *>(static_cast<const void *>(a))
-    %as_voidptrptr(a)        	 reinterpret_cast<void **>(a)
-
-  or their C unsafe versions. In C++ we use the safe version unless
-  SWIG_NO_CPLUSPLUS_CAST is defined (usually via the -nocppcast swig flag).
-
-
-  Memory allocation:
-  ------------------
-
-  These allocation/freeing macros are safe to use in C or C++ and
-  dispatch the proper new/delete/delete[] or free/malloc calls as
-  needed.
-
-    %new_instance(Type)             Allocate a new instance of given Type
-    %new_copy(value,Type)           Allocate and initialize a new instance with 'value'
-    %new_array(size,Type)           Allocate a new array with given size and Type
-    %new_copy_array(cptr,size,Type) Allocate and initialize a new array from 'cptr'
-    %delete(cptr)                   Delete an instance
-    %delete_array(cptr)             Delete an array
-
-
-  Auxiliary loop macros:
-  ----------------------
-
-    %formacro(Macro, Args...) or %formacro_1(Macro, Args...)
-       for i in Args
-       do
-          Macro($i)
-       done
-
-    %formacro_2(Macro2, Args...)
-       for i,j in Args
-       do
-          Macro2($i, $j)
-       done
-
-
-  Flags and conditional macros:
-  -----------------------------
-
-     %mark_flag(flag)
-       flag := True
-
-     %evalif(flag,expr)
-       if flag; then
-         expr
-       fi
-
-     %evalif_2(flag1 flag2,expr)
-       if flag1 and flag2; then
-         expr
-       fi
-
-
-*/
-/* -----------------------------------------------------------------------------
- * Basic preprocessor macros
- * ----------------------------------------------------------------------------- */
-
-#define %arg(Arg...)        Arg
-#define %str(Arg)           `Arg`
-#ifndef %begin_block
-#  define %begin_block      do {
-#endif
-#ifndef %end_block
-#  define %end_block        } while(0)
-#endif
-#define %block(Block...)    %begin_block Block; %end_block
-
-/* define a new macro */
-%define %define_as(Def, Val...)%#define Def Val %enddef
-
-/* include C++ or else value */
-%define %ifcplusplus(cppval, nocppval)
-#ifdef __cplusplus
-cppval
-#else
-nocppval
-#endif
-%enddef
-
-/* insert the SWIGVERSION in the interface and the wrapper code */
-#if SWIG_VERSION
-%insert("header") {
-%define_as(SWIGVERSION,  SWIG_VERSION)
-%#define SWIG_VERSION SWIGVERSION
-}
-#endif
-
-
-
-/* -----------------------------------------------------------------------------
- * Casting operators
- * ----------------------------------------------------------------------------- */
-
-#if defined(SWIG_NO_CPLUSPLUS_CAST)
-/* Disable 'modern' cplusplus casting operators */
-# if defined(SWIG_CPLUSPLUS_CAST)
-#   undef SWIG_CPLUSPLUS_CAST
-# endif
-#endif
-
-#if defined(__cplusplus) && defined(SWIG_CPLUSPLUS_CAST)
-# define %const_cast(a,Type...)       const_cast< Type >(a)
-# define %static_cast(a,Type...)      static_cast< Type >(a)
-# define %reinterpret_cast(a,Type...) reinterpret_cast< Type >(a)
-# define %numeric_cast(a,Type...)     static_cast< Type >(a)
-#else /* C case */
-# define %const_cast(a,Type...)       (Type)(a)
-# define %static_cast(a,Type...)      (Type)(a)
-# define %reinterpret_cast(a,Type...) (Type)(a)
-# define %numeric_cast(a,Type...)     (Type)(a)
-#endif /* __cplusplus */
-
-
-#define %as_voidptr(a)               SWIG_as_voidptr(a)
-#define %as_voidptrptr(a)            SWIG_as_voidptrptr(a)
-
-%insert("header") {
-%define_as(SWIG_as_voidptr(a),    %const_cast(%static_cast(a,const void *), void *))
-%define_as(SWIG_as_voidptrptr(a), ((void)%as_voidptr(*a),%reinterpret_cast(a, void**)))
-}
-
-
-/* -----------------------------------------------------------------------------
- * Allocating/freeing elements
- * ----------------------------------------------------------------------------- */
-
-#if defined(__cplusplus)
-# define %new_instance(Type...)             (new Type)
-# define %new_copy(val,Type...)             (new Type(%static_cast(val, const Type&)))
-# define %new_array(size,Type...)           (new Type[size])
-# define %new_copy_array(ptr,size,Type...)  %reinterpret_cast(memcpy(%new_array(size,Type), ptr, sizeof(Type)*(size)), Type*)
-# define %delete(cptr)                      delete cptr
-# define %delete_array(cptr)                delete[] cptr
-#else /* C case */
-# define %new_instance(Type...)             (Type *)malloc(sizeof(Type))
-# define %new_copy(val,Type...)             (Type *)memcpy(%new_instance(Type),&val,sizeof(Type))
-# define %new_array(size,Type...)           (Type *)malloc((size)*sizeof(Type))
-# define %new_copy_array(ptr,size,Type...)  (Type *)memcpy(%new_array(size,Type), ptr, sizeof(Type)*(size))
-# define %delete(cptr)                      free((char*)cptr)
-# define %delete_array(cptr)                free((char*)cptr)
-#endif /* __cplusplus */
-
-/* -----------------------------------------------------------------------------
- * SWIG names and mangling
- * ----------------------------------------------------------------------------- */
-
-#define %mangle(Type...)                  #@Type
-#define %descriptor(Type...)               SWIGTYPE_ ## #@Type
-#define %string_name(Name)                "SWIG_" %str(Name)
-#define %symbol_name(Name, Type...)       SWIG_ ## Name ## _ #@Type
-#define %checkcode(Code)           	  SWIG_TYPECHECK_ ## Code
-
-
-/* -----------------------------------------------------------------------------
- * Auxiliary loop macros
- * ----------------------------------------------------------------------------- */
-
-
-/* for loop for macro with one argument */
-%define %_formacro_1(macro, arg1,...)macro(arg1)
-#if #__VA_ARGS__ != "__fordone__"
-%_formacro_1(macro, __VA_ARGS__)
-#endif
-%enddef
-
-/* for loop for macro with one argument */
-%define %formacro_1(macro,...)%_formacro_1(macro,__VA_ARGS__,__fordone__)%enddef
-%define %formacro(macro,...)%_formacro_1(macro,__VA_ARGS__,__fordone__)%enddef
-
-/* for loop for macro with two arguments */
-%define %_formacro_2(macro, arg1, arg2, ...)macro(arg1, arg2)
-#if #__VA_ARGS__ != "__fordone__"
-%_formacro_2(macro, __VA_ARGS__)
-#endif
-%enddef
-
-/* for loop for macro with two arguments */
-%define %formacro_2(macro,...)%_formacro_2(macro, __VA_ARGS__, __fordone__)%enddef
-
-/* -----------------------------------------------------------------------------
- * SWIG flags
- * ----------------------------------------------------------------------------- */
-
-/*
-  mark a flag, ie, define a macro name but ignore it in
-  the interface.
-
-  the flag can be later used with %evalif
-*/
-
-%define %mark_flag(x) %define x 1 %enddef %enddef
-
-
-/*
-  %evalif and %evalif_2 are use to evaluate or process
-  an expression if the given predicate is 'true' (1).
-*/
-%define %_evalif(_x,_expr)
-#if _x == 1
-_expr
-#endif
-%enddef
-
-%define %_evalif_2(_x,_y,_expr)
-#if _x == 1 && _y == 1
-_expr
-#endif
-%enddef
-
-%define %evalif(_x,_expr...) %_evalif(%arg(_x),%arg(_expr)) %enddef
-
-%define %evalif_2(_x,_y,_expr...) %_evalif_2(%arg(_x),%arg(_y),%arg(_expr)) %enddef
-
diff --git a/share/swig/2.0.11/typemaps/swigtype.swg b/share/swig/2.0.11/typemaps/swigtype.swg
deleted file mode 100644
index 4f5e01a..0000000
--- a/share/swig/2.0.11/typemaps/swigtype.swg
+++ /dev/null
@@ -1,607 +0,0 @@
-/* -----------------------------------------------------------------------------
- * --- Input arguments --- 
- * ----------------------------------------------------------------------------- */
-/* Pointers and arrays */
-%typemap(in, noblock=1) SWIGTYPE *(void  *argp = 0, int res = 0) {
-  res = SWIG_ConvertPtr($input, &argp,$descriptor, $disown | %convertptr_flags);
-  if (!SWIG_IsOK(res)) { 
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  $1 = %reinterpret_cast(argp, $ltype);
-}
-%typemap(freearg) SWIGTYPE * "";
-
-%typemap(in, noblock=1) SWIGTYPE [] (void *argp = 0, int res = 0) {
-  res = SWIG_ConvertPtr($input, &argp,$descriptor, $disown | %convertptr_flags);
-  if (!SWIG_IsOK(res)) { 
-    %argument_fail(res, "$type", $symname, $argnum); 
-  } 
-  $1 = %reinterpret_cast(argp, $ltype);
-}
-%typemap(freearg) SWIGTYPE [] "";
-
-
-%typemap(in, noblock=1) SWIGTYPE *const&  (void *argp = 0, int res = 0, $*1_ltype temp) {
-  res = SWIG_ConvertPtr($input, &argp, $*descriptor, $disown | %convertptr_flags);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$*ltype", $symname, $argnum); 
-  }
-  temp = %reinterpret_cast(argp, $*ltype);
-  $1 = %reinterpret_cast(&temp, $1_ltype);
-}
-%typemap(freearg) SWIGTYPE *const& "";
-
-
-/* Reference */
-%typemap(in, noblock=1) SWIGTYPE & (void *argp = 0, int res = 0) {
-  res = SWIG_ConvertPtr($input, &argp, $descriptor, %convertptr_flags);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (!argp) { %argument_nullref("$type", $symname, $argnum); }
-  $1 = %reinterpret_cast(argp, $ltype);
-}
-%typemap(freearg) SWIGTYPE & "";
-
-#if defined(__cplusplus) && defined(%implicitconv_flag)
-%typemap(in,noblock=1,implicitconv=1) const SWIGTYPE & (void *argp = 0, int res = 0) {
-  res = SWIG_ConvertPtr($input, &argp, $descriptor, %convertptr_flags | %implicitconv_flag);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (!argp) { %argument_nullref("$type", $symname, $argnum); }
-  $1 = %reinterpret_cast(argp, $ltype);
-}
-%typemap(freearg,noblock=1,match="in",implicitconv=1) const SWIGTYPE &
-{
-  if (SWIG_IsNewObj(res$argnum)) %delete($1);
-}
-#else
-%typemap(in,noblock=1) const SWIGTYPE & (void *argp, int res = 0) {
-  res = SWIG_ConvertPtr($input, &argp, $descriptor, %convertptr_flags);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }
-  if (!argp) { %argument_nullref("$type", $symname, $argnum); }
-  $1 = %reinterpret_cast(argp, $ltype);
-}
-#endif
-
-/* By value */
-#if defined(__cplusplus) && defined(%implicitconv_flag)
-%typemap(in,implicitconv=1) SWIGTYPE (void *argp, int res = 0) {
-  res = SWIG_ConvertPtr($input, &argp, $&descriptor, %convertptr_flags | %implicitconv_flag);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }  
-  if (!argp) { 
-    %argument_nullref("$type", $symname, $argnum);
-  } else {
-    $&ltype temp = %reinterpret_cast(argp, $&ltype);
-    $1 = *temp;
-    if (SWIG_IsNewObj(res)) %delete(temp);
-  }
-}
-#else
-%typemap(in) SWIGTYPE (void *argp, int res = 0) {
-  res = SWIG_ConvertPtr($input, &argp, $&descriptor, %convertptr_flags);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res, "$type", $symname, $argnum); 
-  }  
-  if (!argp) { 
-    %argument_nullref("$type", $symname, $argnum);
-  } else {
-    $1 = *(%reinterpret_cast(argp, $&ltype));
-  }
-}
-#endif
-
-
-/* -----------------------------------------------------------------------------
- * --- Output arguments --- 
- * ----------------------------------------------------------------------------- */
-
-/* Pointers, references */
-%typemap(out,noblock=1) SWIGTYPE *, SWIGTYPE &, SWIGTYPE[] {
-  %set_output(SWIG_NewPointerObj(%as_voidptr($1), $descriptor, $owner | %newpointer_flags));
-}
-
-%typemap(out, noblock=1) SWIGTYPE *const& {
-  %set_output(SWIG_NewPointerObj(%as_voidptr(*$1), $*descriptor, $owner | %newpointer_flags));
-}
-
-/* Return by value */
-%typemap(out, noblock=1) SWIGTYPE {
-  %set_output(SWIG_NewPointerObj(%new_copy($1, $ltype), $&descriptor, SWIG_POINTER_OWN | %newpointer_flags));
-}
-
-/* -----------------------------------------------------------------------------
- * --- Variable input --- 
- * ----------------------------------------------------------------------------- */
-
-/* memberin/globalin/varin, for fix arrays. */
-
-%typemap(memberin) SWIGTYPE [ANY] {
-  if ($input) {
-    size_t ii = 0;
-    for (; ii < (size_t)$1_dim0; ++ii) $1[ii] = $input[ii];
-  } else {
-    %variable_nullref("$type","$name");
-  }
-}
-
-%typemap(globalin) SWIGTYPE [ANY] {
-  if ($input) {
-    size_t ii = 0;
-    for (; ii < (size_t)$1_dim0; ++ii) $1[ii] = $input[ii];
-  } else {
-    %variable_nullref("$type","$name");
-  }
-}
-
-%typemap(varin) SWIGTYPE [ANY] {
-  $basetype *inp = 0;
-  int res = SWIG_ConvertPtr($input, %as_voidptrptr(&inp), $descriptor, %convertptr_flags);
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res, "$type", "$name");
-  } else if (inp) {
-    size_t ii = 0;
-    for (; ii < (size_t)$1_dim0; ++ii) $1[ii] = inp[ii];
-  } else {
-    %variable_nullref("$type", "$name");
-  }
-}
-
-
-/* memberin/globalin/varin, for fix double arrays. */
-
-%typemap(memberin) SWIGTYPE [ANY][ANY] {
-  if ($input) {
-    size_t ii = 0;
-    for (; ii < (size_t)$1_dim0; ++ii) {
-      if ($input[ii]) {
-	size_t jj = 0;
-	for (; jj < (size_t)$1_dim1; ++jj) $1[ii][jj] = $input[ii][jj];
-      } else {
-	%variable_nullref("$type","$name");
-      }
-    }
-  } else {
-    %variable_nullref("$type","$name");
-  }
-}
-
-%typemap(globalin) SWIGTYPE [ANY][ANY] {
-  if ($input) {
-    size_t ii = 0;
-    for (; ii < (size_t)$1_dim0; ++ii) {
-      if ($input[ii]) {
-	size_t jj = 0;
-	for (; jj < (size_t)$1_dim1; ++jj) $1[ii][jj] = $input[ii][jj];
-      } else {
-	%variable_nullref("$type","$name");
-      }
-    }
-  } else {
-    %variable_nullref("$type","$name");
-  }
-}
-
-%typemap(varin) SWIGTYPE [ANY][ANY] {
-  $basetype (*inp)[$1_dim1] = 0;
-  int res = SWIG_ConvertPtr($input, %as_voidptrptr(&inp), $descriptor, %convertptr_flags);
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res, "$type", "$name");
-  } else if (inp) {
-    size_t ii = 0;
-    for (; ii < (size_t)$1_dim0; ++ii) {
-      if (inp[ii]) {
-	size_t jj = 0;
-	for (; jj < (size_t)$1_dim1; ++jj) $1[ii][jj] = inp[ii][jj];
-      } else {
-	%variable_nullref("$type", "$name");
-      }
-    }
-  } else {
-    %variable_nullref("$type", "$name");
-  }
-}
-
-/* Pointers, references, and variable size arrays */
-
-%typemap(varin,warning=SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG) SWIGTYPE * {
-  void *argp = 0;
-  int res = SWIG_ConvertPtr($input, &argp, $descriptor, %convertptr_flags);  
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res, "$type", "$name");
-  }
-  $1 = %reinterpret_cast(argp, $ltype);
-}
-
-%typemap(varin,noblock=1,warning="462:Unable to set dimensionless array variable") SWIGTYPE []
-{
-  %variable_fail(SWIG_AttributeError, "$type", "read-only $name");
-}
-
-%typemap(varin,warning=SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG) SWIGTYPE & {
-  void *argp = 0;
-  int res = SWIG_ConvertPtr($input, &argp, $descriptor, %convertptr_flags);
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res, "$type", "$name");
-  }
-  if (!argp) {
-    %variable_nullref("$type", "$name");
-  }
-  $1 = *(%reinterpret_cast(argp, $ltype));
-}
-
-#if defined(__cplusplus) && defined(%implicitconv_flag)
-%typemap(varin,implicitconv=1) SWIGTYPE {
-  void *argp = 0;
-  int res = SWIG_ConvertPtr($input, &argp, $&descriptor, %convertptr_flags | %implicitconv_flag);
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res, "$type", "$name");
-  }
-  if (!argp) {
-    %variable_nullref("$type", "$name");
-  } else {
-    $&type temp;
-    temp  = %reinterpret_cast(argp, $&type);
-    $1 = *temp;
-    if (SWIG_IsNewObj(res)) %delete(temp);
-  }
-}
-#else
-%typemap(varin) SWIGTYPE {
-  void *argp = 0;
-  int res = SWIG_ConvertPtr($input, &argp, $&descriptor, %convertptr_flags);
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res, "$type", "$name");
-  }
-  if (!argp) {
-    %variable_nullref("$type", "$name");
-  } else {
-    $1 = *(%reinterpret_cast(argp, $&type));
-  }
-}
-#endif
-
-/* -----------------------------------------------------------------------------
- * --- Variable output --- 
- * ----------------------------------------------------------------------------- */
-
-/* Pointers and arrays */
-%typemap(varout, noblock=1) SWIGTYPE * {
-  %set_varoutput(SWIG_NewPointerObj(%as_voidptr($1), $descriptor, %newpointer_flags));
-}
-
-%typemap(varout, noblock=1) SWIGTYPE [] {
-  %set_varoutput(SWIG_NewPointerObj(%as_voidptr($1), $descriptor, %newpointer_flags));
-}
-
-/* References */
-%typemap(varout, noblock=1) SWIGTYPE & {
-  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(&$1), $descriptor, %newpointer_flags));
-}
-
-/* Value */
-%typemap(varout, noblock=1) SWIGTYPE {
-  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(&$1), $&descriptor, %newpointer_flags));
-}
-
-/* ------------------------------------------------------------
- * --- Typechecking rules ---
- * ------------------------------------------------------------ */
-
-%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1) SWIGTYPE * {
-  void *vptr = 0;
-  int res = SWIG_ConvertPtr($input, &vptr, $descriptor, 0);
-  $1 = SWIG_CheckState(res);
-}
-
-%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1) SWIGTYPE *const& {
-  void *vptr = 0;
-  int res = SWIG_ConvertPtr($input, &vptr, $*descriptor, 0);
-  $1 = SWIG_CheckState(res);
-}
-
-%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1) SWIGTYPE & {
-  void *vptr = 0;
-  int res = SWIG_ConvertPtr($input, &vptr, $descriptor, 0);
-  $1 = SWIG_CheckState(res);
-}
-
-#if defined(__cplusplus) && defined(%implicitconv_flag)
-%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1,implicitconv=1) const SWIGTYPE & {
-  int res = SWIG_ConvertPtr($input, 0, $descriptor, %implicitconv_flag);
-  $1 = SWIG_CheckState(res);
-}
-
-%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1,implicitconv=1) SWIGTYPE {
-  int res = SWIG_ConvertPtr($input, 0, $&descriptor, %implicitconv_flag);
-  $1 = SWIG_CheckState(res);
-}
-#else
-%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1) const SWIGTYPE & {
-  void *vptr = 0;
-  int res = SWIG_ConvertPtr($input, &vptr, $descriptor, 0);
-  $1 = SWIG_CheckState(res);
-}
-
-%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1) SWIGTYPE {
-  void *vptr = 0;
-  int res = SWIG_ConvertPtr($input, &vptr, $&descriptor, 0);
-  $1 = SWIG_CheckState(res);
-}
-#endif
-
-/* -----------------------------------------------------------------------------
- * --- Director typemaps --- *  
- * ----------------------------------------------------------------------------- */
-
-#if defined(SWIG_DIRECTOR_TYPEMAPS)
-
-/* directorin */
-
-%typemap(directorin,noblock=1) SWIGTYPE *, SWIGTYPE *const& {
-  $input = SWIG_NewPointerObj(%as_voidptr($1), $descriptor, %newpointer_flags);
-}
-
-%typemap(directorin,noblock=1) SWIGTYPE {
-  $input = SWIG_NewPointerObj(%as_voidptr(&$1), $&descriptor, %newpointer_flags);
-}
-
-%typemap(directorin,noblock=1) SWIGTYPE & {
-  $input = SWIG_NewPointerObj(%as_voidptr(&$1), $descriptor, %newpointer_flags);
-}
-
-/* directorout */
-#if defined(__cplusplus) && defined(%implicitconv_flag)
-%typemap(directorout,noblock=1,implicitconv=1) SWIGTYPE (void * swig_argp, int swig_res = 0) {
-  swig_res = SWIG_ConvertPtr($input,&swig_argp,$&descriptor, %convertptr_flags | %implicitconv_flag);
-  if (!SWIG_IsOK(swig_res)) {
-    %dirout_fail(swig_res,"$type");
-  }
-  $result = *(%reinterpret_cast(swig_argp, $&ltype));
-  if (SWIG_IsNewObj(swig_res)) %delete(%reinterpret_cast(swig_argp, $&ltype));
-}
-#else
-%typemap(directorout,noblock=1) SWIGTYPE (void * swig_argp, int swig_res = 0) {
-  swig_res = SWIG_ConvertPtr($input,&swig_argp,$&descriptor, %convertptr_flags);
-  if (!SWIG_IsOK(swig_res)) {
-    %dirout_fail(swig_res,"$type");
-  }
-  $result = *(%reinterpret_cast(swig_argp, $&ltype));
-}
-#endif
-
-%typemap(directorout,noblock=1,warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) 
-  SWIGTYPE *(void *swig_argp, int swig_res, swig_owntype own) {
-  swig_res = SWIG_ConvertPtrAndOwn($input, &swig_argp, $descriptor, %convertptr_flags | SWIG_POINTER_DISOWN, &own);
-  if (!SWIG_IsOK(swig_res)) {
-    %dirout_fail(swig_res,"$type");
-  }
-  $result = %reinterpret_cast(swig_argp, $ltype);
-  swig_acquire_ownership_obj(%as_voidptr($result), own /* & TODO: SWIG_POINTER_OWN */);
-}
-%typemap(directorfree,noblock=1,match="directorout") SWIGTYPE * {
-  if (director) {
-    SWIG_AcquirePtr($result, director->swig_release_ownership(%as_voidptr($input)));
-  }
-}
-
-%typemap(directorout,noblock=1,warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) 
-  SWIGTYPE &(void *swig_argp, int swig_res, swig_owntype own) {
-  swig_res = SWIG_ConvertPtrAndOwn($input, &swig_argp, $descriptor, %convertptr_flags | SWIG_POINTER_DISOWN, &own);
-  if (!SWIG_IsOK(swig_res)) {
-    %dirout_fail(swig_res,"$type");
-  }
-  if (!swig_argp) { %dirout_nullref("$type"); }
-  $result = %reinterpret_cast(swig_argp, $ltype);
-  swig_acquire_ownership_obj(%as_voidptr($result), own /* & TODO: SWIG_POINTER_OWN */);
-}
-%typemap(directorfree,noblock=1,match="directorout") SWIGTYPE & {
-  if (director) {
-    SWIG_AcquirePtr($result, director->swig_release_ownership(%as_voidptr($input)));
-  }
-}
-
-#endif /* SWIG_DIRECTOR_TYPEMAPS */
-
-
-/* ------------------------------------------------------------
- * --- Constants ---
- * ------------------------------------------------------------ */
-
-%typemap(constcode,noblock=1) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
-  %set_constant("$symname", SWIG_NewPointerObj(%as_voidptr($value),$descriptor,%newpointer_flags));
-}
-
-%typemap(constcode,noblock=1) SWIGTYPE {
-  %set_constant("$symname", SWIG_NewPointerObj(%as_voidptr(&$value),$&descriptor,%newpointer_flags));
-}
-
-/* ------------------------------------------------------------
- * --- Exception handling ---
- * ------------------------------------------------------------ */
-
-%typemap(throws,noblock=1) SWIGTYPE {
-  %raise(SWIG_NewPointerObj(%new_copy($1, $ltype),$&descriptor,SWIG_POINTER_OWN), "$type", $&descriptor);
-}
-
-%typemap(throws,noblock=1) SWIGTYPE * {
-  %raise(SWIG_NewPointerObj(%as_voidptr($1),$descriptor,0), "$type", $descriptor);
-}
-
-%typemap(throws,noblock=1) SWIGTYPE [ANY] {
-  %raise(SWIG_NewPointerObj(%as_voidptr($1),$descriptor,0), "$type", $descriptor);
-}
-
-%typemap(throws,noblock=1) SWIGTYPE & {
-  %raise(SWIG_NewPointerObj(%as_voidptr(&$1),$descriptor,0), "$type", $descriptor);
-}
-
-%typemap(throws,noblock=1) (...) {
-  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
-}
-
-/* ------------------------------------------------------------
- * --- CLASS::* typemaps --- 
- * ------------------------------------------------------------ */
-
-%typemap(in) SWIGTYPE (CLASS::*) {  
-  int res = SWIG_ConvertMember($input, %as_voidptr(&$1), sizeof($type),$descriptor);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res,"$type",$symname, $argnum); 
-  }
-}
-
-%typemap(out,noblock=1) SWIGTYPE (CLASS::*) {
-  %set_output(SWIG_NewMemberObj(%as_voidptr(&$1), sizeof($type), $descriptor));
-}
-
-%typemap(varin) SWIGTYPE (CLASS::*) {
-  int res = SWIG_ConvertMember($input,%as_voidptr(&$1), sizeof($type), $descriptor);
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res, "$type", "$name"); 
-  }
-}
-
-%typemap(varout,noblock=1) SWIGTYPE (CLASS::*) {
-  %set_varoutput(SWIG_NewMemberObj(%as_voidptr(&$1), sizeof($type), $descriptor));
-}
-
-%typemap(constcode,noblock=1) SWIGTYPE (CLASS::*) {
-  %set_constant("$symname", SWIG_NewMemberObj(%as_voidptr(&$value), sizeof($type), $descriptor));
-}
-
-#if defined(SWIG_DIRECTOR_TYPEMAPS)
-
-/* directorin */
-
-%typemap(directorin,noblock=1) SWIGTYPE (CLASS::*) {
-  $input = SWIG_NewMemberObj(%as_voidptr(&$1), sizeof($type), $descriptor);
-}
-
-/* directorout */
-
-%typemap(directorout) SWIGTYPE (CLASS::*) {
-  int swig_res = SWIG_ConvertMember($input,%as_voidptr(&$result), sizeof($type), $descriptor);
-  if (!SWIG_IsOK(swig_res)) {
-    %dirout_fail(swig_res,"$type");
-  }
-}
-#endif
-
-/* ------------------------------------------------------------
- * --- function ptr typemaps --- 
- * ------------------------------------------------------------ */
-
-/*
-  ISO C++ doesn't allow direct casting of a function ptr to a object
-  ptr. So, maybe the ptr sizes are not the same, and we need to take
-  some providences.
- */
-%typemap(in) SWIGTYPE ((*)(ANY)) {
-  int res = SWIG_ConvertFunctionPtr($input, (void**)(&$1), $descriptor);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res,"$type",$symname, $argnum); 
-  }
-}
-
-%typecheck(SWIG_TYPECHECK_POINTER,noblock=1) SWIGTYPE ((*)(ANY)) {
-  void *ptr = 0;
-  int res = SWIG_ConvertFunctionPtr($input, &ptr, $descriptor);
-  $1 = SWIG_CheckState(res);
-}
-
-
-%typemap(out, noblock=1) SWIGTYPE ((*)(ANY)) {
-  %set_output(SWIG_NewFunctionPtrObj((void *)($1), $descriptor));
-}
-
-%typemap(varin) SWIGTYPE ((*)(ANY)) {
-  int res = SWIG_ConvertFunctionPtr($input, (void**)(&$1), $descriptor);
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res, "$type", "$name"); 
-  }
-}
-
-%typemap(varout,noblock=1) SWIGTYPE ((*)(ANY)) {  
-  %set_varoutput(SWIG_NewFunctionPtrObj((void *)($1), $descriptor));
-}
-
-%typemap(constcode, noblock=1) SWIGTYPE ((*)(ANY)){
-  %set_constant("$symname", SWIG_NewFunctionPtrObj((void *)$value, $descriptor));
-}
-
-#if defined(SWIG_DIRECTOR_TYPEMAPS)
-
-/* directorin */
-
-%typemap(directorin,noblock=1) SWIGTYPE ((*)(ANY)) {
-  $input = SWIG_NewFunctionPtrObj((void*)($1), $descriptor);
-}
-
-/* directorout */
-
-%typemap(directorout) SWIGTYPE ((*)(ANY)) {
-  int swig_res = SWIG_ConvertFunctionPtr($input,(void**)(&$result),$descriptor);
-  if (!SWIG_IsOK(swig_res)) {
-    %dirout_fail(swig_res,"$type");
-  }
-}
-#endif
-
-%apply SWIGTYPE * { SWIGTYPE *const }
-
-/* ------------------------------------------------------------
- * --- Special typemaps ---
- * ------------------------------------------------------------ */
-
-/* DISOWN typemap */
-
-%typemap(in, noblock=1) SWIGTYPE *DISOWN (int res = 0) {
-  res = SWIG_ConvertPtr($input, %as_voidptrptr(&$1), $descriptor, SWIG_POINTER_DISOWN | %convertptr_flags);
-  if (!SWIG_IsOK(res)) {
-    %argument_fail(res,"$type", $symname, $argnum);
-  }
-}
-
-%typemap(varin) SWIGTYPE *DISOWN {
-  void *temp = 0;
-  int res = SWIG_ConvertPtr($input, &temp, $descriptor, SWIG_POINTER_DISOWN | %convertptr_flags);
-  if (!SWIG_IsOK(res)) {
-    %variable_fail(res, "$type", "$name");
-  }
-  $1 = ($ltype) temp;
-}
-
-/* DYNAMIC typemap */
-
-%typemap(out,noblock=1) SWIGTYPE *DYNAMIC, SWIGTYPE &DYNAMIC {
-  %set_output(SWIG_NewPointerObj(%as_voidptr($1), SWIG_TypeDynamicCast($descriptor, %as_voidptrptr(&$1)), $owner | %newpointer_flags));
-}
-
-/* INSTANCE typemap */
-
-%typemap(out,noblock=1) SWIGTYPE INSTANCE {
-  %set_output(SWIG_NewInstanceObj(%new_copy($1, $1_ltype), $&1_descriptor, SWIG_POINTER_OWN | %newinstance_flags));
-}
-
-%typemap(out,noblock=1) SWIGTYPE *INSTANCE, SWIGTYPE &INSTANCE, SWIGTYPE INSTANCE[] {
-  %set_output(SWIG_NewInstanceObj(%as_voidptr($1), $1_descriptor, $owner | %newinstance_flags));
-}
-
-%typemap(varout,noblock=1) SWIGTYPE *INSTANCE, SWIGTYPE INSTANCE[] {
-  %set_varoutput(SWIG_NewInstanceObj(%as_voidptr($1), $1_descriptor, %newinstance_flags));
-}
-
-%typemap(varout,noblock=1) SWIGTYPE &INSTANCE {
-  %set_varoutput(SWIG_NewInstanceObj(%as_voidptr($1), $1_descriptor, %newinstance_flags));
-}
-
-%typemap(varout,noblock=1) SWIGTYPE INSTANCE {
-  %set_varoutput(SWIG_NewInstanceObj(%as_voidptr(&$1), $&1_descriptor, %newinstance_flags));
-}
-
diff --git a/share/swig/2.0.11/typemaps/swigtypemaps.swg b/share/swig/2.0.11/typemaps/swigtypemaps.swg
deleted file mode 100644
index 0e39afe..0000000
--- a/share/swig/2.0.11/typemaps/swigtypemaps.swg
+++ /dev/null
@@ -1,167 +0,0 @@
-/* -----------------------------------------------------------------------------
- * swigtypemaps.swg
- *
- * Unified Typemap Library frontend
- * ----------------------------------------------------------------------------- */
-
-/*
-  This file provides the frontend to the Unified Typemap Library.
-
-  When using this library in a SWIG target language, you need to
-  define a minimum set of fragments, specialize a couple of macros,
-  and then include this file.
-
-  Typically you will create a 'mytypemaps.swg' file in each target
-  languge, where you will have the following sections:
-
-    === mytypemaps.swg ===
-
-    //  Fragment section 
-    %include <typemaps/fragments.swg>
-    <include target language fragments>
-
-    // Unified typemap section 
-    <specialized the typemap library macros>
-    %include <typemaps/swigtypemaps.swg>
-
-    // Local typemap section 
-    <add/replace extra target language typemaps>
-
-    === mytypemaps.swg ===
-
-  While we add more docs, please take a look at the following cases
-  to see how you specialized the unified typemap library for a new
-  target language:
-
-      Lib/python/pytypemaps.swg
-      Lib/tcl/tcltypemaps.swg
-      Lib/ruby/rubytypemaps.swg
-      Lib/perl5/perltypemaps.swg
-    
-*/
-
-#define SWIGUTL SWIGUTL
-
-/* -----------------------------------------------------------------------------
- *   Language specialization section. 
- *
- *   Tune these macros for each language as needed.
- * ----------------------------------------------------------------------------- */
-
-/*
-  The SWIG target language object must be provided.
-  For example in python you define:
-
-    #define SWIG_Object PyObject *
-*/
-
-#if !defined(SWIG_Object) 
-#error "SWIG_Object must be defined as the SWIG target language object"
-#endif
-
-/*==== flags for new/convert methods ====*/
-
-
-#ifndef %convertptr_flags
-%define %convertptr_flags  0 %enddef
-#endif
-
-#ifndef %newpointer_flags
-%define %newpointer_flags  0 %enddef
-#endif
-
-#ifndef %newinstance_flags
-%define %newinstance_flags 0 %enddef
-#endif
-
-/*==== set output ====*/
-
-#ifndef %set_output
-/* simple set output operation */
-#define %set_output(obj)                  $result = obj
-#endif
-
-/*==== set variable output  ====*/
-
-#ifndef %set_varoutput
-/* simple set varoutput operation */
-#define %set_varoutput(obj)               $result = obj
-#endif
-
-/*==== append output ====*/
-
-#ifndef %append_output
-#if defined(SWIG_AppendOutput)
-/* simple append operation */
-#define %append_output(obj)               $result = SWIG_AppendOutput($result,obj) 
-#else
-#error "Language must define SWIG_AppendOutput or %append_output"
-#endif
-#endif
-
-/*==== set constant ====*/
-
-#ifndef %set_constant
-#if defined(SWIG_SetConstant)
-/* simple set constant operation */
-#define %set_constant(name,value)         SWIG_SetConstant(name,value)
-#else
-#error "Language must define SWIG_SetConstant or %set_constant"
-#endif
-#endif
-
-/*==== raise an exception ====*/
-
-#ifndef %raise
-#if defined(SWIG_Raise)
-/* simple raise operation */
-#define %raise(obj, type, desc)           SWIG_Raise(obj, type, desc); SWIG_fail
-#else
-#error "Language must define SWIG_Raise or %raise"
-#endif
-#endif
-
-/*==== director output exception ====*/
-
-#if defined(SWIG_DIRECTOR_TYPEMAPS)
-#ifndef SWIG_DirOutFail
-#define SWIG_DirOutFail(code, msg)        Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(code), msg)
-#endif
-#endif
-
-
-/* -----------------------------------------------------------------------------
- *  Language independent definitions
- * ----------------------------------------------------------------------------- */
-
-#define %error_block(Block...)                 %block(Block)
-#define %default_code(code)                    SWIG_ArgError(code)  
-#define %argument_fail(code, type, name, argn) SWIG_exception_fail(%default_code(code), %argfail_fmt(type, name, argn))
-#define %argument_nullref(type, name, argn)    SWIG_exception_fail(SWIG_ValueError, %argnullref_fmt(type, name, argn))
-#define %variable_fail(code, type, name)       SWIG_exception_fail(%default_code(code), %varfail_fmt(type, name))
-#define %variable_nullref(type, name)          SWIG_exception_fail(SWIG_ValueError, %varnullref_fmt(type, name))
-
-#if defined(SWIG_DIRECTOR_TYPEMAPS)
-#define %dirout_fail(code, type)          SWIG_DirOutFail(%default_code(code), %outfail_fmt(type))
-#define %dirout_nullref(type)             SWIG_DirOutFail(SWIG_ValueError, %outnullref_fmt(type))
-#endif
-
-/* -----------------------------------------------------------------------------
- *  All the typemaps
- * ----------------------------------------------------------------------------- */
-
-
-%include <typemaps/fragments.swg>
-%include <typemaps/exception.swg>
-%include <typemaps/swigtype.swg>
-%include <typemaps/void.swg>
-%include <typemaps/swigobject.swg>
-%include <typemaps/valtypes.swg>
-%include <typemaps/ptrtypes.swg>
-%include <typemaps/inoutlist.swg>
-%include <typemaps/primtypes.swg>
-%include <typemaps/string.swg>
-%include <typemaps/misctypes.swg>
-%include <typemaps/enumint.swg>
-
-
diff --git a/share/swig/2.0.11/typemaps/traits.swg b/share/swig/2.0.11/typemaps/traits.swg
deleted file mode 100644
index b39eb39..0000000
--- a/share/swig/2.0.11/typemaps/traits.swg
+++ /dev/null
@@ -1,307 +0,0 @@
-//
-// Use the following macro with modern STL implementations
-//
-//#define SWIG_STD_MODERN_STL
-//
-// Use this to deactive the previous definition, when using gcc-2.95
-// or similar old compilers.
-//
-//#define SWIG_STD_NOMODERN_STL
-
-// Here, we identify compilers we now have problems with STL.
-%{
-#if defined(__GNUC__)
-#  if __GNUC__ == 2 && __GNUC_MINOR <= 96
-#     define SWIG_STD_NOMODERN_STL
-#  endif
-#endif
-%}
-
-//
-// Common code for supporting the STD C++ namespace
-//
-
-%{
-#include <string>
-#include <stdexcept>
-%}
-
-%fragment("Traits","header") 
-{
-namespace swig {  
-  /*
-    type categories
-  */
-  struct pointer_category { };  
-  struct value_category { };
-
-  /*
-    General traits that provides type_name and type_info
-  */
-  template <class Type> struct traits { };
-
-  template <class Type>
-  inline const char* type_name() {
-    return traits<Type>::type_name();
-  }
-
-  template <class Type> 
-  struct traits_info {
-    static swig_type_info *type_query(std::string name) {
-      name += " *";
-      return SWIG_TypeQuery(name.c_str());
-    }    
-    static swig_type_info *type_info() {
-      static swig_type_info *info = type_query(type_name<Type>());
-      return info;
-    }
-  };
-
-  template <class Type>
-  inline swig_type_info *type_info() {
-    return traits_info<Type>::type_info();
-  }
-
-  /*
-    Partial specialization for pointers
-  */
-  template <class Type> struct traits <Type *> {
-    typedef pointer_category category;
-    static std::string make_ptr_name(const char* name) {
-      std::string ptrname = name;
-      ptrname += " *";
-      return ptrname;
-    }    
-    static const char* type_name() {
-      static std::string name = make_ptr_name(swig::type_name<Type>());
-      return name.c_str();
-    }
-  };
-
- 
-  template <class Type, class Category = typename traits<Type>::category > 
-  struct traits_check { };
-
-  /*
-    Traits that provides the from method for an unknown type
-  */
-  template <int flags, class Type> struct traits_from_ptr {
-    static SWIG_Object from SWIG_FROM_DECL_ARGS(Type *val) {
-      return SWIG_NewPointerObj(val, type_info<Type>(), flags);
-    }
-  };
-
-  template <class Type> struct traits_from {
-    static SWIG_Object from SWIG_FROM_DECL_ARGS(const Type& val) {
-      return traits_from_ptr<SWIG_POINTER_OWN, Type>::from(new Type(val));
-    }
-  };
-
-  template <class Type> struct traits_from<Type *> {
-    static SWIG_Object from SWIG_FROM_DECL_ARGS(Type* val) {
-      return traits_from_ptr<0, Type>::from(val);
-    }
-  };
-
-  template <class Type>
-  inline SWIG_Object from SWIG_FROM_DECL_ARGS(const Type& val) {
-    return traits_from<Type>::from(val);
-  }
-
-  /*
-    Traits that provides the asptr/asval method for an unknown type
-  */
-  template <class Type>
-  struct traits_asptr {   
-    static int asptr SWIG_AS_DECL_ARGS (SWIG_Object obj, Type **val) {
-      Type *p;
-      int res = SWIG_ConvertPtr(obj, %as_voidptrptr(&p), type_info<Type>(), 0);
-      if (SWIG_IsOK(res) && val) *val = p;
-      return res;
-    }
-  }; 
-
-  template <class Type>
-  inline int asptr SWIG_AS_DECL_ARGS(SWIG_Object obj, Type **vptr) {
-    return traits_asptr<Type>::asptr SWIG_AS_CALL_ARGS(obj, vptr);
-  }
-
-  template <class Type> 
-  struct traits_asval {
-    static int asval SWIG_AS_DECL_ARGS(SWIG_Object obj, Type *val) {
-      if (val) {
-	Type *p = 0;
-	int res = traits_asptr<Type>::asptr SWIG_AS_CALL_ARGS(obj, &p);
-	if (SWIG_IsOK(res) && p) {
-	  *val = *p;
-	  if (SWIG_IsNewObj(res)) {
-	    %delete(p);
-	    res = SWIG_DelNewMask(res);
-	  }
-	}
-	return res;
-      } else {
-	return traits_asptr<Type>::asptr SWIG_AS_CALL_ARGS(obj, (Type **)(0));
-      }
-    }
-  };
-  
-  template <class Type>
-  inline int asval SWIG_AS_DECL_ARGS (SWIG_Object obj, Type *val) {
-    return traits_asval<Type>::asval SWIG_AS_CALL_ARGS(obj, val);
-  }
-
-  /*
-    Traits that provides the check method for an unknown type
-  */
-#define SWIG_CHECK_DECL_ARGS(obj) SWIG_AS_DECL_ARGS(obj, void * = 0)
-#define SWIG_CHECK_CALL_ARGS(obj) SWIG_AS_CALL_ARGS(obj, 0)
-
-  template <class Type> 
-  struct traits_checkval {
-    static int check SWIG_CHECK_DECL_ARGS(SWIG_Object obj) {
-      if (obj) {
-	int res = asval SWIG_AS_CALL_ARGS(obj, (Type *)(0));
-	return SWIG_CheckState(res);
-      } else {
-	return 0;
-      }
-    }
-  };
-
-  template <class Type> 
-  struct traits_checkptr {
-    static int check SWIG_CHECK_DECL_ARGS(SWIG_Object obj) {
-      if (obj) {
-	int res = asptr SWIG_AS_CALL_ARGS(obj, (Type **)(0));
-	return SWIG_CheckState(res);
-      } else {
-	return 0;
-      }
-    }
-  };
-
-  template <class Type> 
-  struct traits_check<Type, value_category> : traits_checkval<Type> {
-  };
-
-  template <class Type> 
-  struct traits_check<Type, pointer_category> : traits_checkptr<Type> {
-  };
-
-  template <class Type>
-  inline int check SWIG_CHECK_DECL_ARGS(SWIG_Object obj) {
-    return traits_check<Type>::check SWIG_CHECK_CALL_ARGS(obj);
-  }
-
-}
-}
- 
-/*
-  Generate the traits for an unknown SWIGTYPE
-*/
-
-%define %traits_swigtype(Type...)
-%fragment(SWIG_Traits_frag(Type),"header",fragment="Traits") {
-  namespace swig {
-    template <>  struct traits<Type > {
-      typedef pointer_category category;
-      static const char* type_name() { return  #Type; }
-    };
-  }
-}
-%enddef
-
-
-/*
-  Generate the traits for a 'value' type, such as 'double',
-  for which the SWIG_AsVal and SWIG_From methods are already defined.
-*/
-
-%define %traits_value(Type...)
-%fragment(SWIG_Traits_frag(Type),"header",
-	  fragment=SWIG_AsVal_frag(Type),
-	  fragment=SWIG_From_frag(Type),
-	  fragment="Traits") {
-namespace swig {
-  template <> struct traits<Type > {
-    typedef value_category category;
-    static const char* type_name() { return  #Type; }
-  };  
-
-  template <>  struct traits_asval<Type > {   
-    typedef Type value_type;
-    static int asval SWIG_AS_DECL_ARGS (SWIG_Object obj, value_type *val) {
-      return SWIG_AsVal(Type)(obj, val);
-    }
-  };
-
-  template <>  struct traits_from<Type > {
-    typedef Type value_type;
-    static SWIG_Object from SWIG_FROM_DECL_ARGS (const value_type& val) {
-      return SWIG_From(Type)(val);
-    }
-  };
-}
-}
-%enddef
-
-/*
-  Generate the traits for a 'pointer' type, such as 'std::string',
-  for which the SWIG_AsPtr and SWIG_From methods are already defined.
-*/
-
-%define %traits_pointer(Type...)
-%fragment(SWIG_Traits_frag(Type),"header",
-	  fragment=SWIG_AsVal_frag(Type),
-	  fragment=SWIG_From_frag(Type),
-	  fragment="Traits") {
-namespace swig {
-  template <> struct traits<Type > {
-    typedef pointer_category category;
-    static const char* type_name() { return  #Type; }
-  };  
-    
-  template <>  struct traits_asptr<Type > {   
-    typedef Type value_type;
-    static int asptr SWIG_AS_DECL_ARGS (SWIG_Object obj, value_type **val) {
-      return SWIG_AsPtr(Type)(obj, val);
-    }
-  };
-
-  template <>  struct traits_from<Type > {
-    typedef Type value_type;
-    static SWIG_Object from SWIG_FROM_DECL_ARGS (const value_type& val) {
-      return SWIG_From(Type)(val);
-    }
-  };
-}
-}
-%enddef
-
-/*
-  Generate the typemaps for a class that has 'value' traits
-*/
-
-%define %typemap_traits_value(Code,Type...)
-  %typemaps_asvalfrom(%arg(Code),
-		      %arg(swig::asval),
-		      %arg(swig::from),
-		      %arg(SWIG_Traits_frag(Type)),
-		      %arg(SWIG_Traits_frag(Type)),
-		      Type);
-%enddef
-
-/*
-  Generate the typemaps for a class that has 'pointer' traits
-*/
-
-%define %typemap_traits_pointer(Code,Type...)
-  %typemaps_asptrfrom(%arg(Code),
-		      %arg(swig::asptr),
-		      %arg(swig::from),
-		      %arg(SWIG_Traits_frag(Type)),
-		      %arg(SWIG_Traits_frag(Type)),
-		      Type);
-%enddef
-
diff --git a/share/swig/2.0.11/typemaps/wstring.swg b/share/swig/2.0.11/typemaps/wstring.swg
deleted file mode 100644
index 2567dc7..0000000
--- a/share/swig/2.0.11/typemaps/wstring.swg
+++ /dev/null
@@ -1,25 +0,0 @@
-%ensure_fragment(SWIG_AsWCharPtrAndSize)
-%ensure_fragment(SWIG_FromWCharPtrAndSize)
-
-
-%types(wchar_t *);
-
-%fragment("SWIG_pwchar_descriptor","header") {
-SWIGINTERN swig_type_info*
-SWIG_pwchar_descriptor()
-{
-  static int init = 0;
-  static swig_type_info* info = 0;
-  if (!init) {
-    info = SWIG_TypeQuery("_p_wchar_t");
-    init = 1;
-  }
-  return info;
-}
-}
-
-%include <typemaps/strings.swg>
-%typemaps_string(%checkcode(UNISTRING), %checkcode(UNICHAR),
-		 wchar_t, WChar, SWIG_AsWCharPtrAndSize, SWIG_FromWCharPtrAndSize, wcslen,
-		"<wchar.h>", WCHAR_MIN, WCHAR_MAX)
-
diff --git a/share/swig/3.0.12/allegrocl/allegrocl.swg b/share/swig/3.0.12/allegrocl/allegrocl.swg
new file mode 100644
index 0000000..152e5e6
--- /dev/null
+++ b/share/swig/3.0.12/allegrocl/allegrocl.swg
@@ -0,0 +1,613 @@
+/* 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 &, 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 &&, 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)";
+%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 &, 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 &, 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[], 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 &, 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]) }
+%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/3.0.12/allegrocl/inout_typemaps.i
index d8d61fe..d8d61fe 100644
--- a/share/swig/2.0.11/allegrocl/inout_typemaps.i
+++ b/share/swig/3.0.12/allegrocl/inout_typemaps.i
diff --git a/share/swig/2.0.11/allegrocl/longlongs.i b/share/swig/3.0.12/allegrocl/longlongs.i
index a15adcd..a15adcd 100644
--- a/share/swig/2.0.11/allegrocl/longlongs.i
+++ b/share/swig/3.0.12/allegrocl/longlongs.i
diff --git a/share/swig/2.0.11/allegrocl/std_list.i b/share/swig/3.0.12/allegrocl/std_list.i
index 4e26089..4e26089 100644
--- a/share/swig/2.0.11/allegrocl/std_list.i
+++ b/share/swig/3.0.12/allegrocl/std_list.i
diff --git a/share/swig/2.0.11/allegrocl/std_string.i b/share/swig/3.0.12/allegrocl/std_string.i
index cbcd250..cbcd250 100644
--- a/share/swig/2.0.11/allegrocl/std_string.i
+++ b/share/swig/3.0.12/allegrocl/std_string.i
diff --git a/share/swig/2.0.11/allegrocl/typemaps.i b/share/swig/3.0.12/allegrocl/typemaps.i
index 293d1cd..293d1cd 100644
--- a/share/swig/2.0.11/allegrocl/typemaps.i
+++ b/share/swig/3.0.12/allegrocl/typemaps.i
diff --git a/share/swig/3.0.12/allkw.swg b/share/swig/3.0.12/allkw.swg
new file mode 100644
index 0000000..b941319
--- /dev/null
+++ b/share/swig/3.0.12/allkw.swg
@@ -0,0 +1,36 @@
+#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 checking 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 separate languagekw.swg
+  file, and add it here.
+  
+*/
+
+%include <chicken/chickenkw.swg>
+%include <csharp/csharpkw.swg>
+%include <d/dkw.swg>
+%include <go/gokw.swg>
+%include <java/javakw.swg>
+%include <lua/luakw.swg>
+%include <ocaml/ocamlkw.swg>
+%include <perl5/perlkw.swg>
+%include <php5/phpkw.swg>
+%include <php/phpkw.swg>
+%include <pike/pikekw.swg>
+%include <python/pythonkw.swg>
+%include <r/rkw.swg>
+%include <ruby/rubykw.swg>
+%include <tcl/tclkw.swg>
+
+
+#endif //__Lib_allkw_swg__
diff --git a/share/swig/2.0.11/attribute.i b/share/swig/3.0.12/attribute.i
index d580dbf..d580dbf 100644
--- a/share/swig/2.0.11/attribute.i
+++ b/share/swig/3.0.12/attribute.i
diff --git a/share/swig/3.0.12/carrays.i b/share/swig/3.0.12/carrays.i
new file mode 100644
index 0000000..3a9c3cf
--- /dev/null
+++ b/share/swig/3.0.12/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/3.0.12/cdata.i b/share/swig/3.0.12/cdata.i
new file mode 100644
index 0000000..3ac693c
--- /dev/null
+++ b/share/swig/3.0.12/cdata.i
@@ -0,0 +1,119 @@
+/* -----------------------------------------------------------------------------
+ * 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 SWIGPHP5
+
+%typemap(out) SWIGCDATA {
+  ZVAL_STRINGL($result, $1.data, $1.len, 1);
+}
+%typemap(in) (const void *indata, int inlen) = (char *STRING, int LENGTH);
+
+#elif SWIGPHP7
+
+%typemap(out) SWIGCDATA {
+  ZVAL_STRINGL($result, $1.data, $1.len);
+}
+%typemap(in) (const void *indata, int inlen) = (char *STRING, int LENGTH);
+
+#elif SWIGJAVA
+
+%apply (char *STRING, int LENGTH) { (const void *indata, int inlen) }
+%typemap(jni) SWIGCDATA "jbyteArray"
+%typemap(jtype) SWIGCDATA "byte[]"
+%typemap(jstype) SWIGCDATA "byte[]"
+%fragment("SWIG_JavaArrayOutCDATA", "header") {
+static jbyteArray SWIG_JavaArrayOutCDATA(JNIEnv *jenv, char *result, jsize sz) {
+  jbyte *arr;
+  int i;
+  jbyteArray jresult = JCALL1(NewByteArray, jenv, sz);
+  if (!jresult)
+    return NULL;
+  arr = JCALL2(GetByteArrayElements, jenv, jresult, 0);
+  if (!arr)
+    return NULL;
+  for (i=0; i<sz; i++)
+    arr[i] = (jbyte)result[i];
+  JCALL3(ReleaseByteArrayElements, jenv, jresult, arr, 0);
+  return jresult;
+}
+}
+%typemap(out, fragment="SWIG_JavaArrayOutCDATA") SWIGCDATA
+%{$result = SWIG_JavaArrayOutCDATA(jenv, (char *)$1.data, $1.len); %}
+%typemap(javaout) SWIGCDATA {
+    return $jnicall;
+  }
+
+#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/3.0.12/cffi/cffi.swg b/share/swig/3.0.12/cffi/cffi.swg
new file mode 100644
index 0000000..3ad767e
--- /dev/null
+++ b/share/swig/3.0.12/cffi/cffi.swg
@@ -0,0 +1,292 @@
+/* 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 &, 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 &, 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 &, 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 &&,
+                                   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]) }
+%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/3.0.12/chicken/chicken.swg b/share/swig/3.0.12/chicken/chicken.swg
new file mode 100644
index 0000000..17f0d0a
--- /dev/null
+++ b/share/swig/3.0.12/chicken/chicken.swg
@@ -0,0 +1,809 @@
+/* -----------------------------------------------------------------------------
+ * 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& };
+%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 &, 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,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 &&, 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);
+}
+
+%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 &&, 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 &&, 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);
+  }
+}
+
+%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);
+}
+
+%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]) }
+%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/3.0.12/chicken/chickenkw.swg
index d2c26c7..d2c26c7 100644
--- a/share/swig/2.0.11/chicken/chickenkw.swg
+++ b/share/swig/3.0.12/chicken/chickenkw.swg
diff --git a/share/swig/3.0.12/chicken/chickenrun.swg b/share/swig/3.0.12/chicken/chickenrun.swg
new file mode 100644
index 0000000..f134001
--- /dev/null
+++ b/share/swig/3.0.12/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 its 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 its 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/3.0.12/chicken/multi-generic.scm
index 9d2e31d..9d2e31d 100644
--- a/share/swig/2.0.11/chicken/multi-generic.scm
+++ b/share/swig/3.0.12/chicken/multi-generic.scm
diff --git a/share/swig/2.0.11/chicken/std_string.i b/share/swig/3.0.12/chicken/std_string.i
index fa77c15..fa77c15 100644
--- a/share/swig/2.0.11/chicken/std_string.i
+++ b/share/swig/3.0.12/chicken/std_string.i
diff --git a/share/swig/2.0.11/chicken/swigclosprefix.scm b/share/swig/3.0.12/chicken/swigclosprefix.scm
index e4bd72b..e4bd72b 100644
--- a/share/swig/2.0.11/chicken/swigclosprefix.scm
+++ b/share/swig/3.0.12/chicken/swigclosprefix.scm
diff --git a/share/swig/2.0.11/chicken/tinyclos-multi-generic.patch b/share/swig/3.0.12/chicken/tinyclos-multi-generic.patch
index 2e58596..2e58596 100644
--- a/share/swig/2.0.11/chicken/tinyclos-multi-generic.patch
+++ b/share/swig/3.0.12/chicken/tinyclos-multi-generic.patch
diff --git a/share/swig/2.0.11/chicken/typemaps.i b/share/swig/3.0.12/chicken/typemaps.i
index fd587fd..fd587fd 100644
--- a/share/swig/2.0.11/chicken/typemaps.i
+++ b/share/swig/3.0.12/chicken/typemaps.i
diff --git a/share/swig/2.0.11/clisp/clisp.swg b/share/swig/3.0.12/clisp/clisp.swg
index e1d330c..e1d330c 100644
--- a/share/swig/2.0.11/clisp/clisp.swg
+++ b/share/swig/3.0.12/clisp/clisp.swg
diff --git a/share/swig/2.0.11/cmalloc.i b/share/swig/3.0.12/cmalloc.i
index 9f58bc0..9f58bc0 100644
--- a/share/swig/2.0.11/cmalloc.i
+++ b/share/swig/3.0.12/cmalloc.i
diff --git a/share/swig/2.0.11/constraints.i b/share/swig/3.0.12/constraints.i
index 8bc7f91..8bc7f91 100644
--- a/share/swig/2.0.11/constraints.i
+++ b/share/swig/3.0.12/constraints.i
diff --git a/share/swig/2.0.11/cpointer.i b/share/swig/3.0.12/cpointer.i
index 881c511..881c511 100644
--- a/share/swig/2.0.11/cpointer.i
+++ b/share/swig/3.0.12/cpointer.i
diff --git a/share/swig/3.0.12/csharp/arrays_csharp.i b/share/swig/3.0.12/csharp/arrays_csharp.i
new file mode 100644
index 0000000..237067a
--- /dev/null
+++ b/share/swig/3.0.12/csharp/arrays_csharp.i
@@ -0,0 +1,139 @@
+/* -----------------------------------------------------------------------------
+ * 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="[global::System.Runtime.InteropServices.In, global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.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="[global::System.Runtime.InteropServices.Out, global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.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="[global::System.Runtime.InteropServices.In, global::System.Runtime.InteropServices.Out, global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.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)
+CSHARP_ARRAYS(bool, bool)
+
+
+%define CSHARP_ARRAYS_FIXED( CTYPE, CSTYPE )
+
+%typemap(ctype)   CTYPE FIXED[] "CTYPE*"
+%typemap(imtype)  CTYPE FIXED[] "global::System.IntPtr"
+%typemap(cstype)  CTYPE FIXED[] "CSTYPE[]"
+%typemap(csin,
+           pre=       "    fixed ( CSTYPE* swig_ptrTo_$csinput = $csinput ) {",
+           terminator="    }") 
+                  CTYPE FIXED[] "(global::System.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)
+CSHARP_ARRAYS_FIXED(bool, bool)
+
diff --git a/share/swig/3.0.12/csharp/boost_intrusive_ptr.i b/share/swig/3.0.12/csharp/boost_intrusive_ptr.i
new file mode 100644
index 0000000..d0a048d
--- /dev/null
+++ b/share/swig/3.0.12/csharp/boost_intrusive_ptr.i
@@ -0,0 +1,510 @@
+// 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) %{
+  // 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 & %{
+  // 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) %{
+  // 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="global::System.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 > *& "global::System.Runtime.InteropServices.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 > {
+    global::System.IntPtr cPtr = $imcall;
+    $typemap(cstype, TYPE) ret = (cPtr == global::System.IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
+    global::System.IntPtr cPtr = $imcall;
+    $typemap(cstype, TYPE) ret = (cPtr == global::System.IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > & {
+    global::System.IntPtr cPtr = $imcall;
+    $typemap(cstype, TYPE) ret = (cPtr == global::System.IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > * {
+    global::System.IntPtr cPtr = $imcall;
+    $typemap(cstype, TYPE) ret = (cPtr == global::System.IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *& {
+    global::System.IntPtr cPtr = $imcall;
+    $typemap(cstype, TYPE) ret = (cPtr == global::System.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 * {
+    global::System.IntPtr cPtr = $imcall;
+    $typemap(cstype, TYPE) ret = (cPtr == global::System.IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) TYPE *CONST& {
+    global::System.IntPtr cPtr = $imcall;
+    $typemap(cstype, TYPE) ret = (cPtr == global::System.IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+    return ret;
+  }
+
+// Base proxy classes
+%typemap(csbody) TYPE %{
+  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+  private bool swigCMemOwnBase;
+
+  PTRCTOR_VISIBILITY $csclassname(global::System.IntPtr cPtr, bool cMemoryOwn) {
+    swigCMemOwnBase = cMemoryOwn;
+    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+  }
+
+  CPTR_VISIBILITY static global::System.Runtime.InteropServices.HandleRef getCPtr($csclassname obj) {
+    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+  }
+%}
+
+// Derived proxy classes
+%typemap(csbody_derived) TYPE %{
+  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+  private bool swigCMemOwnDerived;
+
+  PTRCTOR_VISIBILITY $csclassname(global::System.IntPtr cPtr, bool cMemoryOwn) : base($imclassname.$csclazznameSWIGSmartPtrUpcast(cPtr), true) {
+    swigCMemOwnDerived = cMemoryOwn;
+    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+  }
+
+  CPTR_VISIBILITY static global::System.Runtime.InteropServices.HandleRef getCPtr($csclassname obj) {
+    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+  }
+%}
+
+%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") TYPE {
+    lock(this) {
+      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
+        if (swigCMemOwnBase) {
+          swigCMemOwnBase = false;
+          $imcall;
+        }
+        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+      }
+      global::System.GC.SuppressFinalize(this);
+    }
+  }
+
+%typemap(csdestruct_derived, methodname="Dispose", methodmodifiers="public") TYPE {
+    lock(this) {
+      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
+        if (swigCMemOwnDerived) {
+          swigCMemOwnDerived = false;
+          $imcall;
+        }
+        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+      }
+      global::System.GC.SuppressFinalize(this);
+      base.Dispose();
+    }
+  }
+
+// CONST version needed ???? also for C#
+%typemap(imtype, nopgcpp="1") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > swigSharedPtrUpcast "global::System.Runtime.InteropServices.HandleRef"
+%typemap(imtype, nopgcpp="1") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > swigSharedPtrUpcast "global::System.Runtime.InteropServices.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 > {
+    global::System.IntPtr cPtr = $imcall;
+    return (cPtr == global::System.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 * {
+    global::System.IntPtr cPtr = $imcall;
+    return (cPtr == global::System.IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);
+  }
+%typemap(csout, excode=SWIGEXCODE) TYPE *CONST& {
+    global::System.IntPtr cPtr = $imcall;
+    return (cPtr == global::System.IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);
+  }
+
+// Base proxy classes
+%typemap(csbody) TYPE %{
+  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+  private bool swigCMemOwnBase;
+
+  PTRCTOR_VISIBILITY $csclassname(global::System.IntPtr cPtr, bool cMemoryOwn) {
+    swigCMemOwnBase = cMemoryOwn;
+    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+  }
+
+  CPTR_VISIBILITY static global::System.Runtime.InteropServices.HandleRef getCPtr($csclassname obj) {
+    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+  }
+%}
+
+// Derived proxy classes
+%typemap(csbody_derived) TYPE %{
+  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+  private bool swigCMemOwnDerived;
+
+  PTRCTOR_VISIBILITY $csclassname(global::System.IntPtr cPtr, bool cMemoryOwn) : base($imclassname.$csclazznameSWIGSmartPtrUpcast(cPtr), true) {
+    swigCMemOwnDerived = cMemoryOwn;
+    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+  }
+
+  CPTR_VISIBILITY static global::System.Runtime.InteropServices.HandleRef getCPtr($csclassname obj) {
+    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+  }
+%}
+
+%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") TYPE {
+    lock(this) {
+      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
+        if (swigCMemOwnBase) {
+          swigCMemOwnBase = false;
+          $imcall;
+        }
+        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+      }
+      global::System.GC.SuppressFinalize(this);
+    }
+  }
+
+%typemap(csdestruct_derived, methodname="Dispose", methodmodifiers="public") TYPE {
+    lock(this) {
+      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
+        if (swigCMemOwnDerived) {
+          swigCMemOwnDerived = false;
+          $imcall;
+        }
+        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+      }
+      global::System.GC.SuppressFinalize(this);
+      base.Dispose();
+    }
+  }
+
+
+// CONST version needed ???? also for C#
+%typemap(imtype, nopgcpp="1") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > swigSharedPtrUpcast "global::System.Runtime.InteropServices.HandleRef"
+%typemap(imtype, nopgcpp="1") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > swigSharedPtrUpcast "global::System.Runtime.InteropServices.HandleRef"
+
+
+%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
+%enddef
diff --git a/share/swig/3.0.12/csharp/boost_shared_ptr.i b/share/swig/3.0.12/csharp/boost_shared_ptr.i
new file mode 100644
index 0000000..2b65bf2
--- /dev/null
+++ b/share/swig/3.0.12/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="global::System.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 > *& "global::System.Runtime.InteropServices.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 > {
+    global::System.IntPtr cPtr = $imcall;
+    $typemap(cstype, TYPE) ret = (cPtr == global::System.IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & {
+    global::System.IntPtr cPtr = $imcall;
+    $typemap(cstype, TYPE) ret = (cPtr == global::System.IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * {
+    global::System.IntPtr cPtr = $imcall;
+    $typemap(cstype, TYPE) ret = (cPtr == global::System.IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& {
+    global::System.IntPtr cPtr = $imcall;
+    $typemap(cstype, TYPE) ret = (cPtr == global::System.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 * {
+    global::System.IntPtr cPtr = $imcall;
+    $typemap(cstype, TYPE) ret = (cPtr == global::System.IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) TYPE *CONST& {
+    global::System.IntPtr cPtr = $imcall;
+    $typemap(cstype, TYPE) ret = (cPtr == global::System.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 {
+      global::System.IntPtr cPtr = $imcall;
+      $csclassname ret = (cPtr == global::System.IntPtr.Zero) ? null : new $csclassname(cPtr, true);$excode
+      return ret;
+    } %}
+
+%typemap(csvarout, excode=SWIGEXCODE2) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
+    get {
+      global::System.IntPtr cPtr = $imcall;
+      $typemap(cstype, TYPE) ret = (cPtr == global::System.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 {
+      global::System.IntPtr cPtr = $imcall;
+      $typemap(cstype, TYPE) ret = (cPtr == global::System.IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+      return ret;
+    } %}
+
+
+// Proxy classes (base classes, ie, not derived classes)
+%typemap(csbody) TYPE %{
+  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+  private bool swigCMemOwnBase;
+
+  PTRCTOR_VISIBILITY $csclassname(global::System.IntPtr cPtr, bool cMemoryOwn) {
+    swigCMemOwnBase = cMemoryOwn;
+    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+  }
+
+  CPTR_VISIBILITY static global::System.Runtime.InteropServices.HandleRef getCPtr($csclassname obj) {
+    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+  }
+%}
+
+// Derived proxy classes
+%typemap(csbody_derived) TYPE %{
+  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+  private bool swigCMemOwnDerived;
+
+  PTRCTOR_VISIBILITY $csclassname(global::System.IntPtr cPtr, bool cMemoryOwn) : base($imclassname.$csclazznameSWIGSmartPtrUpcast(cPtr), true) {
+    swigCMemOwnDerived = cMemoryOwn;
+    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+  }
+
+  CPTR_VISIBILITY static global::System.Runtime.InteropServices.HandleRef getCPtr($csclassname obj) {
+    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+  }
+%}
+
+%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") TYPE {
+    lock(this) {
+      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
+        if (swigCMemOwnBase) {
+          swigCMemOwnBase = false;
+          $imcall;
+        }
+        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+      }
+      global::System.GC.SuppressFinalize(this);
+    }
+  }
+
+%typemap(csdestruct_derived, methodname="Dispose", methodmodifiers="public") TYPE {
+    lock(this) {
+      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
+        if (swigCMemOwnDerived) {
+          swigCMemOwnDerived = false;
+          $imcall;
+        }
+        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+      }
+      global::System.GC.SuppressFinalize(this);
+      base.Dispose();
+    }
+  }
+
+%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
+%enddef
+
diff --git a/share/swig/3.0.12/csharp/csharp.swg b/share/swig/3.0.12/csharp/csharp.swg
new file mode 100644
index 0000000..8dc2ba8
--- /dev/null
+++ b/share/swig/3.0.12/csharp/csharp.swg
@@ -0,0 +1,1056 @@
+/* -----------------------------------------------------------------------------
+ * 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. */
+
+/* SWIG 3 no longer inserts using directives into generated C# code. For backwards compatibility, the SWIG2_CSHARP
+   macro can be defined to have SWIG 3 generate using directives similar to those generated by SWIG 2. */
+#ifdef SWIG2_CSHARP
+
+%typemap(csimports)                   SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) "\nusing global::System;\nusing global::System.Runtime.InteropServices;\n"
+
+%pragma(csharp) moduleimports=%{
+using global::System;
+using global::System.Runtime.InteropServices;
+%}
+
+%pragma(csharp) imclassimports=%{
+using global::System;
+using global::System.Runtime.InteropServices;
+%}
+
+#endif
+
+
+/* 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";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    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) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    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="global::System.IntPtr") SWIGTYPE "global::System.Runtime.InteropServices.HandleRef"
+%typemap(cstype) SWIGTYPE "$&csclassname"
+
+%typemap(ctype) SWIGTYPE [] "void *"
+%typemap(imtype, out="global::System.IntPtr") SWIGTYPE [] "global::System.Runtime.InteropServices.HandleRef"
+%typemap(cstype) SWIGTYPE [] "$csclassname"
+
+%typemap(ctype) SWIGTYPE * "void *"
+%typemap(imtype, out="global::System.IntPtr") SWIGTYPE * "global::System.Runtime.InteropServices.HandleRef"
+%typemap(cstype) SWIGTYPE * "$csclassname"
+
+%typemap(ctype) SWIGTYPE & "void *"
+%typemap(imtype, out="global::System.IntPtr") SWIGTYPE & "global::System.Runtime.InteropServices.HandleRef"
+%typemap(cstype) SWIGTYPE & "$csclassname"
+
+%typemap(ctype) SWIGTYPE && "void *"
+%typemap(imtype, out="global::System.IntPtr") SWIGTYPE && "global::System.Runtime.InteropServices.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 = (unsigned long)$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 *)new $1_ltype((const $1_ltype &)$1); %}
+%typemap(csdirectorin) SWIGTYPE "new $&csclassname($iminput, true)"
+%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(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(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(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(directorin) SWIGTYPE &&
+%{ $input = ($1_ltype) &$1; %}
+
+%typemap(csdirectorin) SWIGTYPE *, SWIGTYPE (CLASS::*) "($iminput == global::System.IntPtr.Zero) ? null : new $csclassname($iminput, false)"
+%typemap(csdirectorin) SWIGTYPE & "new $csclassname($iminput, false)"
+%typemap(csdirectorin) SWIGTYPE && "new $csclassname($iminput, false)"
+%typemap(csdirectorout) SWIGTYPE *, SWIGTYPE (CLASS::*), SWIGTYPE &, 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 &&, 
+    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 *, 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 &&, 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 && {
+    $csclassname ret = new $csclassname($imcall, $owner);$excode
+    return ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) SWIGTYPE *, SWIGTYPE [] {
+    global::System.IntPtr cPtr = $imcall;
+    $csclassname ret = (cPtr == global::System.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 [], 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 && %{
+    get {
+      $csclassname ret = new $csclassname($imcall, $owner);$excode
+      return ret;
+    } %}
+%typemap(csvarout, excode=SWIGEXCODE2) SWIGTYPE *, SWIGTYPE [] %{
+    get {
+      global::System.IntPtr cPtr = $imcall;
+      $csclassname ret = (cPtr == global::System.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="global::System.IntPtr") SWIGTYPE *const& "global::System.Runtime.InteropServices.HandleRef"
+%typemap(cstype) SWIGTYPE *const& "$*csclassname"
+%typemap(csin) SWIGTYPE *const& "$*csclassname.getCPtr($csinput)"
+%typemap(csout, excode=SWIGEXCODE) SWIGTYPE *const& {
+    global::System.IntPtr cPtr = $imcall;
+    $*csclassname ret = (cPtr == global::System.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 global::System.IntPtr */
+%typemap(ctype) void *VOID_INT_PTR "void *"
+%typemap(imtype) void *VOID_INT_PTR "global::System.IntPtr"
+%typemap(cstype) void *VOID_INT_PTR "global::System.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 {
+    global::System.IntPtr ret = $imcall;$excode
+    return ret;
+  }
+%typemap(csdirectorin) void *VOID_INT_PTR "$iminput"
+%typemap(csdirectorout) void *VOID_INT_PTR "$cscall"
+
+/* Typemaps used for the generation of proxy and type wrapper class code */
+%typemap(csbase)                      SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+%typemap(csclassmodifiers)            SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) "public class"
+%typemap(cscode)                      SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+%typemap(csinterfaces)                SWIGTYPE "global::System.IDisposable"
+%typemap(csinterfaces)                          SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+%typemap(csinterfaces_derived)        SWIGTYPE, 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 global::System.Runtime.InteropServices.HandleRef swigCPtr;
+  protected bool swigCMemOwn;
+
+  PTRCTOR_VISIBILITY $csclassname(global::System.IntPtr cPtr, bool cMemoryOwn) {
+    swigCMemOwn = cMemoryOwn;
+    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+  }
+
+  CPTR_VISIBILITY static global::System.Runtime.InteropServices.HandleRef getCPtr($csclassname obj) {
+    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+  }
+%}
+
+// Derived proxy classes
+%typemap(csbody_derived) TYPE %{
+  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+
+  PTRCTOR_VISIBILITY $csclassname(global::System.IntPtr cPtr, bool cMemoryOwn) : base($imclassname.$csclazznameSWIGUpcast(cPtr), cMemoryOwn) {
+    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+  }
+
+  CPTR_VISIBILITY static global::System.Runtime.InteropServices.HandleRef getCPtr($csclassname obj) {
+    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+  }
+%}
+%enddef
+
+%define SWIG_CSBODY_TYPEWRAPPER(PTRCTOR_VISIBILITY, DEFAULTCTOR_VISIBILITY, CPTR_VISIBILITY, TYPE...)
+// Typewrapper classes
+%typemap(csbody) TYPE *, TYPE &, TYPE &&, TYPE [] %{
+  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+
+  PTRCTOR_VISIBILITY $csclassname(global::System.IntPtr cPtr, bool futureUse) {
+    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+  }
+
+  DEFAULTCTOR_VISIBILITY $csclassname() {
+    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+  }
+
+  CPTR_VISIBILITY static global::System.Runtime.InteropServices.HandleRef getCPtr($csclassname obj) {
+    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.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 != global::System.IntPtr.Zero) {
+        if (swigCMemOwn) {
+          swigCMemOwn = false;
+          $imcall;
+        }
+        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+      }
+      global::System.GC.SuppressFinalize(this);
+    }
+  }
+
+%typemap(csdestruct_derived, methodname="Dispose", methodmodifiers="public") SWIGTYPE {
+    lock(this) {
+      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
+        if (swigCMemOwn) {
+          swigCMemOwn = false;
+          $imcall;
+        }
+        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+      }
+      global::System.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")
+#define %proxycode                  %insert("proxycode")
+
+%pragma(csharp) imclassclassmodifiers="class"
+%pragma(csharp) moduleclassmodifiers="public class"
+
+/* Some ANSI C typemaps */
+
+%apply unsigned long { size_t };
+%apply const unsigned long & { const size_t & };
+
+/* Array reference typemaps */
+%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+%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 : global::System.IDisposable {
+    public readonly global::System.Runtime.InteropServices.HandleRef swigCPtr;
+    public SWIGStringMarshal(string str) {
+      swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, global::System.Runtime.InteropServices.Marshal.StringToHGlobalAnsi(str));
+    }
+    public virtual void Dispose() {
+      global::System.Runtime.InteropServices.Marshal.FreeHGlobal(swigCPtr.Handle);
+      global::System.GC.SuppressFinalize(this);
+    }
+  }
+%}
+
+%typemap(imtype, out="global::System.IntPtr") char *, char[ANY], char[]   "global::System.Runtime.InteropServices.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 = global::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 = global::System.Runtime.InteropServices.Marshal.PtrToStringAnsi($imcall);$excode
+      return ret;
+    } %}
+*/
+
diff --git a/share/swig/3.0.12/csharp/csharphead.swg b/share/swig/3.0.12/csharp/csharphead.swg
new file mode 100644
index 0000000..0b55635
--- /dev/null
+++ b/share/swig/3.0.12/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);
+
+    [global::System.Runtime.InteropServices.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);
+
+    [global::System.Runtime.InteropServices.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 global::System.ApplicationException(message, SWIGPendingException.Retrieve()));
+    }
+    static void SetPendingArithmeticException(string message) {
+      SWIGPendingException.Set(new global::System.ArithmeticException(message, SWIGPendingException.Retrieve()));
+    }
+    static void SetPendingDivideByZeroException(string message) {
+      SWIGPendingException.Set(new global::System.DivideByZeroException(message, SWIGPendingException.Retrieve()));
+    }
+    static void SetPendingIndexOutOfRangeException(string message) {
+      SWIGPendingException.Set(new global::System.IndexOutOfRangeException(message, SWIGPendingException.Retrieve()));
+    }
+    static void SetPendingInvalidCastException(string message) {
+      SWIGPendingException.Set(new global::System.InvalidCastException(message, SWIGPendingException.Retrieve()));
+    }
+    static void SetPendingInvalidOperationException(string message) {
+      SWIGPendingException.Set(new global::System.InvalidOperationException(message, SWIGPendingException.Retrieve()));
+    }
+    static void SetPendingIOException(string message) {
+      SWIGPendingException.Set(new global::System.IO.IOException(message, SWIGPendingException.Retrieve()));
+    }
+    static void SetPendingNullReferenceException(string message) {
+      SWIGPendingException.Set(new global::System.NullReferenceException(message, SWIGPendingException.Retrieve()));
+    }
+    static void SetPendingOutOfMemoryException(string message) {
+      SWIGPendingException.Set(new global::System.OutOfMemoryException(message, SWIGPendingException.Retrieve()));
+    }
+    static void SetPendingOverflowException(string message) {
+      SWIGPendingException.Set(new global::System.OverflowException(message, SWIGPendingException.Retrieve()));
+    }
+    static void SetPendingSystemException(string message) {
+      SWIGPendingException.Set(new global::System.SystemException(message, SWIGPendingException.Retrieve()));
+    }
+
+    static void SetPendingArgumentException(string message, string paramName) {
+      SWIGPendingException.Set(new global::System.ArgumentException(message, paramName, SWIGPendingException.Retrieve()));
+    }
+    static void SetPendingArgumentNullException(string message, string paramName) {
+      global::System.Exception e = SWIGPendingException.Retrieve();
+      if (e != null) message = message + " Inner Exception: " + e.Message;
+      SWIGPendingException.Set(new global::System.ArgumentNullException(paramName, message));
+    }
+    static void SetPendingArgumentOutOfRangeException(string message, string paramName) {
+      global::System.Exception e = SWIGPendingException.Retrieve();
+      if (e != null) message = message + " Inner Exception: " + e.Message;
+      SWIGPendingException.Set(new global::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 {
+    [global::System.ThreadStatic]
+    private static global::System.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(global::System.Exception e) {
+      if (pendingException != null)
+        throw new global::System.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 global::System.Exception Retrieve() {
+      global::System.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);
+
+    [global::System.Runtime.InteropServices.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/3.0.12/csharp/csharpkw.swg b/share/swig/3.0.12/csharp/csharpkw.swg
new file mode 100644
index 0000000..824f618
--- /dev/null
+++ b/share/swig/3.0.12/csharp/csharpkw.swg
@@ -0,0 +1,97 @@
+#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`
+
+#define CSHARPCLASSKW(x) %keywordwarn("'" `x` "' is a special method name used in the C# wrapper classes, class renamed to '" `x` "_'",%$isclass,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);
+
+CSHARPCLASSKW(delete);
+
+#undef CSHARPKW
+
+#endif //CSHARP_CSHARPKW_SWG_
diff --git a/share/swig/3.0.12/csharp/director.swg b/share/swig/3.0.12/csharp/director.swg
new file mode 100644
index 0000000..3438f2b
--- /dev/null
+++ b/share/swig/3.0.12/csharp/director.swg
@@ -0,0 +1,46 @@
+/* -----------------------------------------------------------------------------
+ * director.swg
+ *
+ * This file contains support for director classes so that C# proxy
+ * methods can be called from C++.
+ * ----------------------------------------------------------------------------- */
+
+#if defined(DEBUG_DIRECTOR_OWNED)
+#include <iostream>
+#endif
+#include <string>
+#include <exception>
+
+namespace Swig {
+  /* Director base class - not currently used in C# directors */
+  class Director {
+  };
+
+  /* Base class for director exceptions */
+  class DirectorException : public std::exception {
+  protected:
+    std::string swig_msg;
+
+  public:
+    DirectorException(const char *msg) : swig_msg(msg) {
+    }
+
+    DirectorException(const std::string &msg) : swig_msg(msg) {
+    }
+
+    virtual ~DirectorException() throw() {
+    }
+
+    const char *what() const throw() {
+      return swig_msg.c_str();
+    }
+  };
+
+  /* Pure virtual method exception */
+  class DirectorPureVirtualException : public DirectorException {
+  public:
+    DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
+    }
+  };
+}
+
diff --git a/share/swig/3.0.12/csharp/enums.swg b/share/swig/3.0.12/csharp/enums.swg
new file mode 100644
index 0000000..5cc2654
--- /dev/null
+++ b/share/swig/3.0.12/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 = (int)*$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 = (int)$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 = (int)$1; %}
+
+%typemap(directorout) enum SWIGTYPE  %{ $result = ($1_ltype)$input; %}
+%typemap(directorin) enum SWIGTYPE "$input = (int)$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/3.0.12/csharp/enumsimple.swg b/share/swig/3.0.12/csharp/enumsimple.swg
new file mode 100644
index 0000000..24e4bcf
--- /dev/null
+++ b/share/swig/3.0.12/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 = (int)*$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 = (int)$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 = (int)$1; %}
+
+%typemap(directorout) enum SWIGTYPE  %{ $result = ($1_ltype)$input; %}
+%typemap(directorin) enum SWIGTYPE "$input = (int)$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/3.0.12/csharp/enumtypesafe.swg b/share/swig/3.0.12/csharp/enumtypesafe.swg
new file mode 100644
index 0000000..fd68017
--- /dev/null
+++ b/share/swig/3.0.12/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 = (int)*$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 = (int)$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 = (int)$1; %}
+
+%typemap(directorout) enum SWIGTYPE  %{ $result = ($1_ltype)$input; %}
+%typemap(directorin) enum SWIGTYPE "$input = (int)$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 global::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/3.0.12/csharp/std_array.i b/share/swig/3.0.12/csharp/std_array.i
new file mode 100644
index 0000000..61bb510
--- /dev/null
+++ b/share/swig/3.0.12/csharp/std_array.i
@@ -0,0 +1,227 @@
+/* -----------------------------------------------------------------------------
+ * std_array.i
+ *
+ * SWIG typemaps for std::array<T, N>
+ * C# implementation
+ * The C# wrapper is made to look and feel like a C# System.Collections.Generic.IReadOnlyList<> collection.
+ * ----------------------------------------------------------------------------- */
+
+%{
+#include <algorithm>
+#include <array>
+#include <stdexcept>
+%}
+
+%include <std_common.i>
+
+
+%define SWIG_STD_ARRAY_INTERNAL(T, N)
+%typemap(csinterfaces) std::array< T, N > "global::System.IDisposable, global::System.Collections.IEnumerable\n    , global::System.Collections.Generic.IEnumerable<$typemap(cstype, T)>\n";
+%proxycode %{
+  public $csclassname(global::System.Collections.ICollection c) : this() {
+    if (c == null)
+      throw new global::System.ArgumentNullException("c");
+    int end = global::System.Math.Min(this.Count, c.Count);
+    int i = 0;
+    foreach ($typemap(cstype, T) elem in c) {
+      if (i >= end)
+        break;
+      this[i++] = elem;
+    }
+  }
+
+  public int Count {
+    get {
+      return (int)size();
+    }
+  }
+
+  public $typemap(cstype, T) this[int index]  {
+    get {
+      return getitem(index);
+    }
+    set {
+      setitem(index, value);
+    }
+  }
+
+  public bool IsEmpty {
+    get {
+      return empty();
+    }
+  }
+
+  public void CopyTo($typemap(cstype, T)[] array)
+  {
+    CopyTo(0, array, 0, this.Count);
+  }
+
+  public void CopyTo($typemap(cstype, T)[] array, int arrayIndex)
+  {
+    CopyTo(0, array, arrayIndex, this.Count);
+  }
+
+  public void CopyTo(int index, $typemap(cstype, T)[] array, int arrayIndex, int count)
+  {
+    if (array == null)
+      throw new global::System.ArgumentNullException("array");
+    if (index < 0)
+      throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero");
+    if (arrayIndex < 0)
+      throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
+    if (count < 0)
+      throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero");
+    if (array.Rank > 1)
+      throw new global::System.ArgumentException("Multi dimensional array.", "array");
+    if (index+count > this.Count || arrayIndex+count > array.Length)
+      throw new global::System.ArgumentException("Number of elements to copy is too large.");
+    for (int i=0; i<count; i++)
+      array.SetValue(getitemcopy(index+i), arrayIndex+i);
+  }
+
+  global::System.Collections.Generic.IEnumerator<$typemap(cstype, T)> global::System.Collections.Generic.IEnumerable<$typemap(cstype, T)>.GetEnumerator() {
+    return new $csclassnameEnumerator(this);
+  }
+
+  global::System.Collections.IEnumerator global::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 : global::System.Collections.IEnumerator
+    , global::System.Collections.Generic.IEnumerator<$typemap(cstype, T)>
+  {
+    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, T) Current {
+      get {
+        if (currentIndex == -1)
+          throw new global::System.InvalidOperationException("Enumeration not started.");
+        if (currentIndex > currentSize - 1)
+          throw new global::System.InvalidOperationException("Enumeration finished.");
+        if (currentObject == null)
+          throw new global::System.InvalidOperationException("Collection modified.");
+        return ($typemap(cstype, T))currentObject;
+      }
+    }
+
+    // Type-unsafe IEnumerator.Current
+    object global::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 global::System.InvalidOperationException("Collection modified.");
+      }
+    }
+
+    public void Dispose() {
+        currentIndex = -1;
+        currentObject = null;
+    }
+  }
+%}
+
+  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;
+
+    array();
+    array(const array &other);
+
+    size_type size() const;
+    bool empty() const;
+
+    %rename(Fill) fill;
+    void fill(const value_type& val);
+
+    %rename(Swap) swap;
+    void swap(array& other);
+
+    %extend {
+      T 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, const_reference val) throw (std::out_of_range) {
+        if (index>=0 && index<(int)$self->size())
+          (*$self)[index] = val;
+        else
+          throw std::out_of_range("index");
+      }
+      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);
+      }
+    }
+%enddef
+
+
+%csmethodmodifiers std::array::empty "private"
+%csmethodmodifiers std::array::getitemcopy "private"
+%csmethodmodifiers std::array::getitem "private"
+%csmethodmodifiers std::array::setitem "private"
+%csmethodmodifiers std::array::size "private"
+
+namespace std {
+  template<class T, size_t N> class array {
+    SWIG_STD_ARRAY_INTERNAL(T, N)
+  };
+}
diff --git a/share/swig/3.0.12/csharp/std_auto_ptr.i b/share/swig/3.0.12/csharp/std_auto_ptr.i
new file mode 100644
index 0000000..d7e5f16
--- /dev/null
+++ b/share/swig/3.0.12/csharp/std_auto_ptr.i
@@ -0,0 +1,25 @@
+/*
+    The typemaps here allow to handle functions returning std::auto_ptr<>,
+    which is the most common use of this type. If you have functions taking it
+    as parameter, these typemaps can't be used for them and you need to do
+    something else (e.g. use shared_ptr<> which SWIG supports fully).
+ */
+
+%define %auto_ptr(TYPE)
+%typemap (ctype) std::auto_ptr<TYPE > "void *"
+%typemap (imtype, out="System.IntPtr") std::auto_ptr<TYPE > "HandleRef"
+%typemap (cstype) std::auto_ptr<TYPE > "$typemap(cstype, TYPE)"
+%typemap (out) std::auto_ptr<TYPE > %{
+   $result = (void *)$1.release();
+%}
+%typemap(csout, excode=SWIGEXCODE) std::auto_ptr<TYPE > {
+     System.IntPtr cPtr = $imcall;
+     $typemap(cstype, TYPE) ret = (cPtr == System.IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+     return ret;
+   }
+%template() std::auto_ptr<TYPE >;
+%enddef
+
+namespace std {
+   template <class T> class auto_ptr {};
+} 
diff --git a/share/swig/2.0.11/csharp/std_common.i b/share/swig/3.0.12/csharp/std_common.i
index cee11e8..cee11e8 100644
--- a/share/swig/2.0.11/csharp/std_common.i
+++ b/share/swig/3.0.12/csharp/std_common.i
diff --git a/share/swig/2.0.11/csharp/std_deque.i b/share/swig/3.0.12/csharp/std_deque.i
index cb98f6c..cb98f6c 100644
--- a/share/swig/2.0.11/csharp/std_deque.i
+++ b/share/swig/3.0.12/csharp/std_deque.i
diff --git a/share/swig/3.0.12/csharp/std_except.i b/share/swig/3.0.12/csharp/std_except.i
new file mode 100644
index 0000000..c983bd0
--- /dev/null
+++ b/share/swig/3.0.12/csharp/std_except.i
@@ -0,0 +1,32 @@
+/* -----------------------------------------------------------------------------
+ * 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 <typeinfo>
+#include <stdexcept>
+%}
+
+namespace std 
+{
+  %ignore exception;
+  struct exception {};
+}
+
+%typemap(throws, canthrow=1) std::bad_cast          "SWIG_CSharpSetPendingException(SWIG_CSharpInvalidCastException, $1.what());\n return $null;"
+%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/3.0.12/csharp/std_map.i b/share/swig/3.0.12/csharp/std_map.i
new file mode 100644
index 0000000..90a8650
--- /dev/null
+++ b/share/swig/3.0.12/csharp/std_map.i
@@ -0,0 +1,307 @@
+/* -----------------------------------------------------------------------------
+ * 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) 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 > "global::System.IDisposable \n    , global::System.Collections.Generic.IDictionary<$typemap(cstype, K), $typemap(cstype, T)>\n";
+%proxycode %{
+
+  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; 
+    }
+  }
+
+  public global::System.Collections.Generic.ICollection<$typemap(cstype, K)> Keys {
+    get {
+      global::System.Collections.Generic.ICollection<$typemap(cstype, K)> keys = new global::System.Collections.Generic.List<$typemap(cstype, K)>();
+      int size = this.Count;
+      if (size > 0) {
+        global::System.IntPtr iter = create_iterator_begin();
+        for (int i = 0; i < size; i++) {
+          keys.Add(get_next_key(iter));
+        }
+        destroy_iterator(iter);
+      }
+      return keys;
+    }
+  }
+
+  public global::System.Collections.Generic.ICollection<$typemap(cstype, T)> Values {
+    get {
+      global::System.Collections.Generic.ICollection<$typemap(cstype, T)> vals = new global::System.Collections.Generic.List<$typemap(cstype, T)>();
+      foreach (global::System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)> pair in this) {
+        vals.Add(pair.Value);
+      }
+      return vals;
+    }
+  }
+  
+  public void Add(global::System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)> item) {
+    Add(item.Key, item.Value);
+  }
+
+  public bool Remove(global::System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)> item) {
+    if (Contains(item)) {
+      return Remove(item.Key);
+    } else {
+      return false;
+    }
+  }
+
+  public bool Contains(global::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(global::System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)>[] array) {
+    CopyTo(array, 0);
+  }
+
+  public void CopyTo(global::System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)>[] array, int arrayIndex) {
+    if (array == null)
+      throw new global::System.ArgumentNullException("array");
+    if (arrayIndex < 0)
+      throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
+    if (array.Rank > 1)
+      throw new global::System.ArgumentException("Multi dimensional array.", "array");
+    if (arrayIndex+this.Count > array.Length)
+      throw new global::System.ArgumentException("Number of elements to copy is too large.");
+
+    global::System.Collections.Generic.IList<$typemap(cstype, K)> keyList = new global::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 global::System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)>(currentKey, this[currentKey]), arrayIndex+i);
+    }
+  }
+
+  global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)>> global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)>>.GetEnumerator() {
+    return new $csclassnameEnumerator(this);
+  }
+
+  global::System.Collections.IEnumerator global::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 : global::System.Collections.IEnumerator, 
+      global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)>>
+  {
+    private $csclassname collectionRef;
+    private global::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 global::System.Collections.Generic.List<$typemap(cstype, K)>(collection.Keys);
+      currentIndex = -1;
+      currentObject = null;
+      currentSize = collectionRef.Count;
+    }
+
+    // Type-safe iterator Current
+    public global::System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)> Current {
+      get {
+        if (currentIndex == -1)
+          throw new global::System.InvalidOperationException("Enumeration not started.");
+        if (currentIndex > currentSize - 1)
+          throw new global::System.InvalidOperationException("Enumeration finished.");
+        if (currentObject == null)
+          throw new global::System.InvalidOperationException("Collection modified.");
+        return (global::System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)>)currentObject;
+      }
+    }
+
+    // Type-unsafe IEnumerator.Current
+    object global::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 global::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 global::System.InvalidOperationException("Collection modified.");
+      }
+    }
+
+    public void Dispose() {
+      currentIndex = -1;
+      currentObject = null;
+    }
+  }
+  
+%}
+
+  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/3.0.12/csharp/std_pair.i
index 0712ad7..0712ad7 100644
--- a/share/swig/2.0.11/csharp/std_pair.i
+++ b/share/swig/3.0.12/csharp/std_pair.i
diff --git a/share/swig/2.0.11/csharp/std_shared_ptr.i b/share/swig/3.0.12/csharp/std_shared_ptr.i
index df87367..df87367 100644
--- a/share/swig/2.0.11/csharp/std_shared_ptr.i
+++ b/share/swig/3.0.12/csharp/std_shared_ptr.i
diff --git a/share/swig/2.0.11/csharp/std_string.i b/share/swig/3.0.12/csharp/std_string.i
index 5f8fa44..5f8fa44 100644
--- a/share/swig/2.0.11/csharp/std_string.i
+++ b/share/swig/3.0.12/csharp/std_string.i
diff --git a/share/swig/3.0.12/csharp/std_vector.i b/share/swig/3.0.12/csharp/std_vector.i
new file mode 100644
index 0000000..12220aa
--- /dev/null
+++ b/share/swig/3.0.12/csharp/std_vector.i
@@ -0,0 +1,402 @@
+/* -----------------------------------------------------------------------------
+ * 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.
+ *
+ * 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 > "global::System.IDisposable, global::System.Collections.IEnumerable\n    , global::System.Collections.Generic.CSINTERFACE<$typemap(cstype, CTYPE)>\n";
+%proxycode %{
+  public $csclassname(global::System.Collections.ICollection c) : this() {
+    if (c == null)
+      throw new global::System.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 global::System.ArgumentOutOfRangeException("Capacity");
+      reserve((uint)value);
+    }
+  }
+
+  public int Count {
+    get {
+      return (int)size();
+    }
+  }
+
+  public bool IsSynchronized {
+    get {
+      return false;
+    }
+  }
+
+  public void CopyTo($typemap(cstype, CTYPE)[] array)
+  {
+    CopyTo(0, array, 0, this.Count);
+  }
+
+  public void CopyTo($typemap(cstype, CTYPE)[] array, int arrayIndex)
+  {
+    CopyTo(0, array, arrayIndex, this.Count);
+  }
+
+  public void CopyTo(int index, $typemap(cstype, CTYPE)[] array, int arrayIndex, int count)
+  {
+    if (array == null)
+      throw new global::System.ArgumentNullException("array");
+    if (index < 0)
+      throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero");
+    if (arrayIndex < 0)
+      throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
+    if (count < 0)
+      throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero");
+    if (array.Rank > 1)
+      throw new global::System.ArgumentException("Multi dimensional array.", "array");
+    if (index+count > this.Count || arrayIndex+count > array.Length)
+      throw new global::System.ArgumentException("Number of elements to copy is too large.");
+    for (int i=0; i<count; i++)
+      array.SetValue(getitemcopy(index+i), arrayIndex+i);
+  }
+
+  global::System.Collections.Generic.IEnumerator<$typemap(cstype, CTYPE)> global::System.Collections.Generic.IEnumerable<$typemap(cstype, CTYPE)>.GetEnumerator() {
+    return new $csclassnameEnumerator(this);
+  }
+
+  global::System.Collections.IEnumerator global::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 : global::System.Collections.IEnumerator
+    , global::System.Collections.Generic.IEnumerator<$typemap(cstype, CTYPE)>
+  {
+    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 global::System.InvalidOperationException("Enumeration not started.");
+        if (currentIndex > currentSize - 1)
+          throw new global::System.InvalidOperationException("Enumeration finished.");
+        if (currentObject == null)
+          throw new global::System.InvalidOperationException("Collection modified.");
+        return ($typemap(cstype, CTYPE))currentObject;
+      }
+    }
+
+    // Type-unsafe IEnumerator.Current
+    object global::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 global::System.InvalidOperationException("Collection modified.");
+      }
+    }
+
+    public void Dispose() {
+        currentIndex = -1;
+        currentObject = null;
+    }
+  }
+%}
+
+  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>
+SWIG_STD_VECTOR_ENHANCED(std::wstring) // also requires a %include <std_wstring.i>
+
diff --git a/share/swig/3.0.12/csharp/std_wstring.i b/share/swig/3.0.12/csharp/std_wstring.i
new file mode 100644
index 0000000..09bdaaa
--- /dev/null
+++ b/share/swig/3.0.12/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="[global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.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="[global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.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/3.0.12/csharp/stl.i
index 9d2e91e..9d2e91e 100644
--- a/share/swig/2.0.11/csharp/stl.i
+++ b/share/swig/3.0.12/csharp/stl.i
diff --git a/share/swig/3.0.12/csharp/swiginterface.i b/share/swig/3.0.12/csharp/swiginterface.i
new file mode 100644
index 0000000..e5bfd23
--- /dev/null
+++ b/share/swig/3.0.12/csharp/swiginterface.i
@@ -0,0 +1,63 @@
+/* -----------------------------------------------------------------------------
+ * swiginterface.i
+ *
+ * SWIG interface feature and typemaps implementation providing:
+ *   %interface
+ *   %interface_impl
+ *   %interface_custom
+ * ----------------------------------------------------------------------------- */
+
+%define INTERFACE_TYPEMAPS(CTYPE...)
+%typemap(cstype) CTYPE "$&csinterfacename"
+%typemap(cstype) CTYPE *, CTYPE [], CTYPE & "$csinterfacename"
+%typemap(cstype) CTYPE *const& "$*csinterfacename"
+%typemap(csin) CTYPE, CTYPE & "$csinput.GetInterfaceCPtr()"
+%typemap(csin) CTYPE *, CTYPE *const&, CTYPE [] "$csinput == null ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : $csinput.GetInterfaceCPtr()"
+%typemap(csout, excode=SWIGEXCODE) CTYPE {
+    $&csclassname ret = new $&csclassname($imcall, true);$excode
+    return ($&csinterfacename)ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) CTYPE & {
+    $csclassname ret = new $csclassname($imcall, $owner);$excode
+    return ($csinterfacename)ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) CTYPE *, CTYPE [] {
+    global::System.IntPtr cPtr = $imcall;
+    $csclassname ret = (cPtr == global::System.IntPtr.Zero) ? null : new $csclassname(cPtr, $owner);$excode
+    return ($csinterfacename)ret;
+  }
+%typemap(csout, excode=SWIGEXCODE) CTYPE *const& {
+    global::System.IntPtr cPtr = $imcall;
+    $*csclassname ret = (cPtr == global::System.IntPtr.Zero) ? null : new $*csclassname(cPtr, $owner);$excode
+    return ($*csinterfacename)ret;
+  }
+%typemap(csdirectorin) CTYPE "($&csinterfacename)new $&csclassname($iminput, true)"
+%typemap(csdirectorin) CTYPE & "($csinterfacename)new $csclassname($iminput, false)"
+%typemap(csdirectorin) CTYPE *, CTYPE [] "($iminput == global::System.IntPtr.Zero) ? null : ($csinterfacename)new $csclassname($iminput, false)"
+%typemap(csdirectorin) CTYPE *const& "($iminput == global::System.IntPtr.Zero) ? null : ($*csinterfacename)new $*csclassname($iminput, false)"
+%typemap(csdirectorout) CTYPE, CTYPE *, CTYPE *const&, CTYPE [], CTYPE & "$cscall.GetInterfaceCPtr()"
+%typemap(csinterfacecode, declaration="  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]\n  global::System.Runtime.InteropServices.HandleRef GetInterfaceCPtr();\n", cptrmethod="$interfacename_GetInterfaceCPtr") CTYPE %{
+  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+  global::System.Runtime.InteropServices.HandleRef $interfacename.GetInterfaceCPtr() {
+    return new global::System.Runtime.InteropServices.HandleRef(this, $imclassname.$csclazzname$interfacename_GetInterfaceCPtr(swigCPtr.Handle));
+  }
+%}
+%enddef
+
+%define %interface(CTYPE...)
+%feature("interface", name="%sSwigInterface") CTYPE;
+INTERFACE_TYPEMAPS(CTYPE)
+%enddef
+
+%define %interface_impl(CTYPE...)
+%rename("%sSwigImpl") CTYPE;
+%feature("interface", name="%(rstrip:[SwigImpl])s") CTYPE;
+INTERFACE_TYPEMAPS(CTYPE)
+%enddef
+
+%define %interface_custom(PROXY, INTERFACE, CTYPE...)
+%rename(PROXY) CTYPE;
+%feature("interface", name=INTERFACE) CTYPE;
+INTERFACE_TYPEMAPS(CTYPE)
+%enddef
+
diff --git a/share/swig/3.0.12/csharp/swigtype_inout.i b/share/swig/3.0.12/csharp/swigtype_inout.i
new file mode 100644
index 0000000..e7312e8
--- /dev/null
+++ b/share/swig/3.0.12/csharp/swigtype_inout.i
@@ -0,0 +1,34 @@
+/* -----------------------------------------------------------------------------
+ * swigtype_inout.i
+ *
+ * Pointer pointer and pointer reference handling typemap library for non-primitive types
+ *
+ * These mappings provide support for input/output arguments and common
+ * uses for C/C++ pointer references and pointer to pointers.
+ *
+ * These are named typemaps (OUTPUT) and can be used like any named typemap.
+ * Alternatively they can be made the default by using %apply:
+ *   %apply SWIGTYPE *& OUTPUT { SWIGTYPE *& }
+ * ----------------------------------------------------------------------------- */
+
+/*
+ * OUTPUT typemaps. Example usage wrapping:
+ *
+ *   void f(XXX *& x) { x = new XXX(111); }
+ *
+ * would be:
+ *
+ *   XXX x = null;
+ *   f(out x);
+ *   // use x
+ *   x.Dispose(); // manually clear memory or otherwise leave out and leave it to the garbage collector
+ */
+%typemap(ctype) SWIGTYPE *& OUTPUT "void **"
+%typemap(imtype, out="global::System.IntPtr") SWIGTYPE *& OUTPUT "out global::System.IntPtr"
+%typemap(cstype) SWIGTYPE *& OUTPUT "out $*csclassname"
+%typemap(csin,
+         pre="    global::System.IntPtr cPtr_$csinput = global::System.IntPtr.Zero;",
+         post="      $csinput = (cPtr_$csinput == global::System.IntPtr.Zero) ? null : new $*csclassname(cPtr_$csinput, true);",
+         cshin="out $csinput") SWIGTYPE *& OUTPUT "out cPtr_$csinput"
+%typemap(in) SWIGTYPE *& OUTPUT %{ $1 = ($1_ltype)$input; %}
+%typemap(freearg) SWIGTYPE *& OUTPUT ""
diff --git a/share/swig/3.0.12/csharp/typemaps.i b/share/swig/3.0.12/csharp/typemaps.i
new file mode 100644
index 0000000..b6f9bdd
--- /dev/null
+++ b/share/swig/3.0.12/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="global::System.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="global::System.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="global::System.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/3.0.12/csharp/wchar.i b/share/swig/3.0.12/csharp/wchar.i
new file mode 100644
index 0000000..9361edf
--- /dev/null
+++ b/share/swig/3.0.12/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(global::System.IntPtr message);
+    static SWIGWStringDelegate wstringDelegate = new SWIGWStringDelegate(CreateWString);
+
+    [global::System.Runtime.InteropServices.DllImport("$dllimport", EntryPoint="SWIGRegisterWStringCallback_$module")]
+    public static extern void SWIGRegisterWStringCallback_$module(SWIGWStringDelegate wstringDelegate);
+
+    static string CreateWString([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]global::System.IntPtr cString) {
+      return global::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="[global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]", out="global::System.IntPtr" ) wchar_t * "string"
+%typemap(cstype) wchar_t * "string"
+
+%typemap(csin) wchar_t * "$csinput"
+%typemap(csout, excode=SWIGEXCODE) wchar_t * {
+    string ret = global::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/3.0.12/cstring.i
index 6829f75..6829f75 100644
--- a/share/swig/2.0.11/cstring.i
+++ b/share/swig/3.0.12/cstring.i
diff --git a/share/swig/2.0.11/cwstring.i b/share/swig/3.0.12/cwstring.i
index f0631d3..f0631d3 100644
--- a/share/swig/2.0.11/cwstring.i
+++ b/share/swig/3.0.12/cwstring.i
diff --git a/share/swig/3.0.12/d/boost_shared_ptr.i b/share/swig/3.0.12/d/boost_shared_ptr.i
new file mode 100644
index 0000000..5c17155
--- /dev/null
+++ b/share/swig/3.0.12/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(typeof(this) 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(typeof(this) 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/3.0.12/d/carrays.i b/share/swig/3.0.12/d/carrays.i
new file mode 100644
index 0000000..f2803ea
--- /dev/null
+++ b/share/swig/3.0.12/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/3.0.12/d/cpointer.i
index 75e610f..75e610f 100644
--- a/share/swig/2.0.11/d/cpointer.i
+++ b/share/swig/3.0.12/d/cpointer.i
diff --git a/share/swig/2.0.11/d/d.swg b/share/swig/3.0.12/d/d.swg
index f5bb459..f5bb459 100644
--- a/share/swig/2.0.11/d/d.swg
+++ b/share/swig/3.0.12/d/d.swg
diff --git a/share/swig/3.0.12/d/dclassgen.swg b/share/swig/3.0.12/d/dclassgen.swg
new file mode 100644
index 0000000..68910b4
--- /dev/null
+++ b/share/swig/3.0.12/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(typeof(this) 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(typeof(this) 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(typeof(this) 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(typeof(this) obj) {
+  return (obj is null) ? null : obj.swigCPtr;
+}
+
+mixin $imdmodule.SwigOperatorDefinitions;
+%}
diff --git a/share/swig/3.0.12/d/ddirectives.swg b/share/swig/3.0.12/d/ddirectives.swg
new file mode 100644
index 0000000..145cf01
--- /dev/null
+++ b/share/swig/3.0.12/d/ddirectives.swg
@@ -0,0 +1,11 @@
+/* -----------------------------------------------------------------------------
+ * 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")
+#define %proxycode                  %insert("proxycode")
diff --git a/share/swig/3.0.12/d/denums.swg b/share/swig/3.0.12/d/denums.swg
new file mode 100644
index 0000000..3f81246
--- /dev/null
+++ b/share/swig/3.0.12/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 = (int)$1; %}
+
+%typemap(directorout) enum SWIGTYPE %{ $result = ($1_ltype)$input; %}
+%typemap(directorin) enum SWIGTYPE "$input = (int)$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 = (int)*$1; %}
+
+%typemap(directorin) const enum SWIGTYPE & "$input = (int)$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/3.0.12/d/dexception.swg
index 1aadbaa..1aadbaa 100644
--- a/share/swig/2.0.11/d/dexception.swg
+++ b/share/swig/3.0.12/d/dexception.swg
diff --git a/share/swig/3.0.12/d/dhead.swg b/share/swig/3.0.12/d/dhead.swg
new file mode 100644
index 0000000..50e9c2e
--- /dev/null
+++ b/share/swig/3.0.12/d/dhead.swg
@@ -0,0 +1,298 @@
+/* -----------------------------------------------------------------------------
+ * 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);
+    SwigPendingException.set(exception);
+  }
+
+  static void setIllegalArgumentException(char* message) {
+    auto exception = new tango.core.Exception.IllegalArgumentException(tango.stdc.stringz.fromStringz(message).dup);
+    SwigPendingException.set(exception);
+  }
+
+  static void setIllegalElementException(char* message) {
+    auto exception = new tango.core.Exception.IllegalElementException(tango.stdc.stringz.fromStringz(message).dup);
+    SwigPendingException.set(exception);
+  }
+
+  static void setIOException(char* message) {
+    auto exception = new tango.core.Exception.IOException(tango.stdc.stringz.fromStringz(message).dup);
+    SwigPendingException.set(exception);
+  }
+
+  static void setNoSuchElementException(char* message) {
+    auto exception = new tango.core.Exception.NoSuchElementException(tango.stdc.stringz.fromStringz(message).dup);
+    SwigPendingException.set(exception);
+  }
+}
+
+package class SwigPendingException {
+public:
+  static this() {
+    m_sPendingException = new ThreadLocalData(null);
+  }
+
+  static bool isPending() {
+    return m_sPendingException.val !is null;
+  }
+
+  static void set(object.Exception e) {
+    auto pending = m_sPendingException.val;
+    if (pending !is null) {
+      e.next = pending;
+      throw new object.Exception("FATAL: An earlier pending exception from C/C++ " ~
+        "code was missed and thus not thrown (" ~ pending.classinfo.name ~ ": " ~
+        pending.msg ~ ")!", e);
+    }
+    m_sPendingException.val = e;
+  }
+
+  static object.Exception retrieve() {
+    auto e = m_sPendingException.val;
+    m_sPendingException.val = null;
+    return e;
+  }
+
+private:
+  // 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));
+    SwigPendingException.set(exception);
+  }
+}
+
+package struct SwigPendingException {
+public:
+  static this() {
+    m_sPendingException = null;
+  }
+
+  static bool isPending() {
+    return m_sPendingException !is null;
+  }
+
+  static void set(object.Exception e) {
+    if (m_sPendingException !is null) {
+      e.next = m_sPendingException;
+      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;
+  }
+
+  static object.Exception retrieve() {
+    auto e = m_sPendingException;
+    m_sPendingException = null;
+    return e;
+  }
+
+private:
+  // 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/3.0.12/d/director.swg b/share/swig/3.0.12/d/director.swg
new file mode 100644
index 0000000..a7d9c76
--- /dev/null
+++ b/share/swig/3.0.12/d/director.swg
@@ -0,0 +1,45 @@
+/* -----------------------------------------------------------------------------
+ * director.swg
+ *
+ * This file contains support for director classes so that D proxy
+ * methods can be called from C++.
+ * ----------------------------------------------------------------------------- */
+
+#if defined(DEBUG_DIRECTOR_OWNED)
+#include <iostream>
+#endif
+#include <string>
+#include <exception>
+
+namespace Swig {
+
+  // Director base class – not used in D directors.
+  class Director {
+  };
+
+  // Base class for director exceptions.
+  class DirectorException : public std::exception {
+  protected:
+    std::string swig_msg;
+
+  public:
+    DirectorException(const std::string &msg) : swig_msg(msg) {
+    }
+
+    virtual ~DirectorException() throw() {
+    }
+
+    const char *what() const throw() {
+      return swig_msg.c_str();
+    }
+  };
+
+  // Exception which is thrown when attempting to call a pure virtual method
+  // from D code through the director layer.
+  class DirectorPureVirtualException : public DirectorException {
+  public:
+    DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempted to invoke pure virtual method ") + msg) {
+    }
+  };
+}
+
diff --git a/share/swig/2.0.11/d/dkw.swg b/share/swig/3.0.12/d/dkw.swg
index 581093f..581093f 100644
--- a/share/swig/2.0.11/d/dkw.swg
+++ b/share/swig/3.0.12/d/dkw.swg
diff --git a/share/swig/3.0.12/d/dmemberfunctionpointers.swg b/share/swig/3.0.12/d/dmemberfunctionpointers.swg
new file mode 100644
index 0000000..c63eca2
--- /dev/null
+++ b/share/swig/3.0.12/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";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    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) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    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/3.0.12/d/doperators.swg
index 0cb6353..0cb6353 100644
--- a/share/swig/2.0.11/d/doperators.swg
+++ b/share/swig/3.0.12/d/doperators.swg
diff --git a/share/swig/2.0.11/d/dprimitives.swg b/share/swig/3.0.12/d/dprimitives.swg
index 4454379..4454379 100644
--- a/share/swig/2.0.11/d/dprimitives.swg
+++ b/share/swig/3.0.12/d/dprimitives.swg
diff --git a/share/swig/2.0.11/d/dstrings.swg b/share/swig/3.0.12/d/dstrings.swg
index 02895c1..02895c1 100644
--- a/share/swig/2.0.11/d/dstrings.swg
+++ b/share/swig/3.0.12/d/dstrings.swg
diff --git a/share/swig/3.0.12/d/dswigtype.swg b/share/swig/3.0.12/d/dswigtype.swg
new file mode 100644
index 0000000..f91d6df
--- /dev/null
+++ b/share/swig/3.0.12/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 *)new $1_ltype((const $1_ltype &)$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, true)"
+%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/3.0.12/d/dvoid.swg
index 805f1e7..805f1e7 100644
--- a/share/swig/2.0.11/d/dvoid.swg
+++ b/share/swig/3.0.12/d/dvoid.swg
diff --git a/share/swig/2.0.11/d/std_common.i b/share/swig/3.0.12/d/std_common.i
index cee11e8..cee11e8 100644
--- a/share/swig/2.0.11/d/std_common.i
+++ b/share/swig/3.0.12/d/std_common.i
diff --git a/share/swig/2.0.11/d/std_deque.i b/share/swig/3.0.12/d/std_deque.i
index cb98f6c..cb98f6c 100644
--- a/share/swig/2.0.11/d/std_deque.i
+++ b/share/swig/3.0.12/d/std_deque.i
diff --git a/share/swig/3.0.12/d/std_except.i b/share/swig/3.0.12/d/std_except.i
new file mode 100644
index 0000000..fbfd6c3
--- /dev/null
+++ b/share/swig/3.0.12/d/std_except.i
@@ -0,0 +1,32 @@
+/* -----------------------------------------------------------------------------
+ * 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 <typeinfo>
+#include <stdexcept>
+%}
+
+namespace std
+{
+  %ignore exception;
+  struct exception {};
+}
+
+%typemap(throws, canthrow=1) std::bad_cast          "SWIG_DSetPendingException(SWIG_DException, $1.what());\n return $null;"
+%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/3.0.12/d/std_map.i
index 0e8574b..0e8574b 100644
--- a/share/swig/2.0.11/d/std_map.i
+++ b/share/swig/3.0.12/d/std_map.i
diff --git a/share/swig/2.0.11/d/std_pair.i b/share/swig/3.0.12/d/std_pair.i
index 0712ad7..0712ad7 100644
--- a/share/swig/2.0.11/d/std_pair.i
+++ b/share/swig/3.0.12/d/std_pair.i
diff --git a/share/swig/2.0.11/d/std_shared_ptr.i b/share/swig/3.0.12/d/std_shared_ptr.i
index df87367..df87367 100644
--- a/share/swig/2.0.11/d/std_shared_ptr.i
+++ b/share/swig/3.0.12/d/std_shared_ptr.i
diff --git a/share/swig/2.0.11/d/std_string.i b/share/swig/3.0.12/d/std_string.i
index 8d75d23..8d75d23 100644
--- a/share/swig/2.0.11/d/std_string.i
+++ b/share/swig/3.0.12/d/std_string.i
diff --git a/share/swig/3.0.12/d/std_vector.i b/share/swig/3.0.12/d/std_vector.i
new file mode 100644
index 0000000..56f7188
--- /dev/null
+++ b/share/swig/3.0.12/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;"
+%proxycode %{
+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;
+%}
+%proxycode %{
+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/3.0.12/d/stl.i
index 9d2e91e..9d2e91e 100644
--- a/share/swig/2.0.11/d/stl.i
+++ b/share/swig/3.0.12/d/stl.i
diff --git a/share/swig/2.0.11/d/typemaps.i b/share/swig/3.0.12/d/typemaps.i
index 4f1b599..4f1b599 100644
--- a/share/swig/2.0.11/d/typemaps.i
+++ b/share/swig/3.0.12/d/typemaps.i
diff --git a/share/swig/2.0.11/d/wrapperloader.swg b/share/swig/3.0.12/d/wrapperloader.swg
index b3c1d0d..b3c1d0d 100644
--- a/share/swig/2.0.11/d/wrapperloader.swg
+++ b/share/swig/3.0.12/d/wrapperloader.swg
diff --git a/share/swig/3.0.12/director_common.swg b/share/swig/3.0.12/director_common.swg
new file mode 100644
index 0000000..9ce93c7
--- /dev/null
+++ b/share/swig/3.0.12/director_common.swg
@@ -0,0 +1,15 @@
+/* -----------------------------------------------------------------------------
+ * director_common.swg
+ *
+ * This file contains support for director classes which is common between
+ * languages.
+ * ----------------------------------------------------------------------------- */
+
+/*
+  Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
+  'Swig' namespace. This could be useful for multi-modules projects.
+*/
+#ifdef SWIG_DIRECTOR_STATIC
+/* Force anonymous (static) namespace */
+#define Swig
+#endif
diff --git a/share/swig/3.0.12/exception.i b/share/swig/3.0.12/exception.i
new file mode 100644
index 0000000..da0d56c
--- /dev/null
+++ b/share/swig/3.0.12/exception.i
@@ -0,0 +1,314 @@
+/* -----------------------------------------------------------------------------
+ * 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 SWIGPHP5
+%{
+#include "zend_exceptions.h"
+#define SWIG_exception(code, msg) do { zend_throw_exception(NULL, (char*)msg, code TSRMLS_CC); goto thrown; } while (0)
+%}
+#endif
+
+#ifdef SWIGPHP7
+%{
+#include "zend_exceptions.h"
+#define SWIG_exception(code, msg) do { zend_throw_exception(NULL, (char*)msg, code); goto thrown; } while (0)
+%}
+#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 <typeinfo>
+#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::bad_cast& e) {
+    SWIG_exception(SWIG_TypeError, 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/3.0.12/gcj/cni.i b/share/swig/3.0.12/gcj/cni.i
new file mode 100644
index 0000000..fcc5668
--- /dev/null
+++ b/share/swig/3.0.12/gcj/cni.i
@@ -0,0 +1,39 @@
+%{
+#include <gcj/cni.h>
+%}
+
+%include <gcj/javaprims.i>
+
+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 (JvVMInitArgs* 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/3.0.12/gcj/cni.swg
index 4bd07df..4bd07df 100644
--- a/share/swig/2.0.11/gcj/cni.swg
+++ b/share/swig/3.0.12/gcj/cni.swg
diff --git a/share/swig/2.0.11/gcj/javaprims.i b/share/swig/3.0.12/gcj/javaprims.i
index 12c92a7..12c92a7 100644
--- a/share/swig/2.0.11/gcj/javaprims.i
+++ b/share/swig/3.0.12/gcj/javaprims.i
diff --git a/share/swig/3.0.12/go/cdata.i b/share/swig/3.0.12/go/cdata.i
new file mode 100644
index 0000000..b4411af
--- /dev/null
+++ b/share/swig/3.0.12/go/cdata.i
@@ -0,0 +1,97 @@
+/* -----------------------------------------------------------------------------
+ * cdata.i
+ *
+ * SWIG library file containing macros for manipulating raw C data as strings.
+ * ----------------------------------------------------------------------------- */
+
+%{
+typedef struct SWIGCDATA {
+    char *data;
+    intgo len;
+} SWIGCDATA;
+%}
+
+%fragment("cdata", "header") %{
+struct swigcdata {
+  intgo size;
+  void *data;
+};
+%}
+
+%typemap(gotype) SWIGCDATA "[]byte"
+
+%typemap(imtype) SWIGCDATA "uint64"
+
+%typemap(out, fragment="cdata") SWIGCDATA(struct swigcdata *swig_out) %{
+  swig_out = (struct swigcdata *)malloc(sizeof(*swig_out));
+  if (swig_out) {
+    swig_out->size = $1.len;
+    swig_out->data = malloc(swig_out->size);
+    if (swig_out->data) {
+      memcpy(swig_out->data, $1.data, swig_out->size);
+    }
+  }
+  $result = *(long long *)(void **)&swig_out;
+%}
+
+%typemap(goout) SWIGCDATA %{
+  {
+    type swigcdata struct { size int; data uintptr }
+    p := (*swigcdata)(unsafe.Pointer(uintptr($1)))
+    if p == nil || p.data == 0 {
+      $result = nil
+    } else {
+      b := make([]byte, p.size)
+      a := (*[0x7fffffff]byte)(unsafe.Pointer(p.data))[:p.size]
+      copy(b, a)
+      Swig_free(p.data)
+      Swig_free(uintptr(unsafe.Pointer(p)))
+      $result = b
+    }
+  }
+%}
+
+/* -----------------------------------------------------------------------------
+ * %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/3.0.12/go/exception.i
index 5abd306..5abd306 100644
--- a/share/swig/2.0.11/go/exception.i
+++ b/share/swig/3.0.12/go/exception.i
diff --git a/share/swig/3.0.12/go/go.swg b/share/swig/3.0.12/go/go.swg
new file mode 100644
index 0000000..53b653f
--- /dev/null
+++ b/share/swig/3.0.12/go/go.swg
@@ -0,0 +1,698 @@
+/* ------------------------------------------------------------
+ * go.swg
+ *
+ * Go configuration module.
+ * ------------------------------------------------------------ */
+
+%include <gostring.swg>
+
+/* Code insertion directives */
+#define %go_import(...) %insert(go_imports) %{__VA_ARGS__%}
+
+/* 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"
+%typemap(gotype) long,               const long &               "int64"
+%typemap(gotype) unsigned long,      const unsigned long &      "uint64"
+%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 long &,
+	     const unsigned long long &,
+	     const float &,
+	     const double &
+%{ $1 = ($1_ltype)&$input; %}
+
+%typemap(in) const long & ($*1_ltype temp),
+	     const unsigned long & ($*1_ltype temp)
+%{ temp = ($*1_ltype)$input;
+   $1 = ($1_ltype)&temp; %}
+
+%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(goout) bool,
+	      char,
+	      signed char,
+	      unsigned char,
+	      short,
+	      unsigned short,
+	      int,
+	      unsigned int,
+	      long,
+	      unsigned long,
+	      long long,
+	      unsigned long long,
+	      float,
+	      double
+""
+
+%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(goout) 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 &
+""
+
+%typemap(out) void ""
+
+%typemap(goout) 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(godirectorin) bool,
+		     char,
+		     signed char,
+		     unsigned char,
+		     short,
+		     unsigned short,
+		     int,
+		     unsigned int,
+		     long,
+		     unsigned long,
+		     long long,
+		     unsigned long long,
+		     float,
+		     double
+""
+
+%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(godirectorin) 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 &
+""
+
+%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,warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) 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 = new $*1_ltype($input);
+  swig_acquire_pointer(&swig_mem, $result);
+%}
+
+/* The size_t type.  */
+
+%typemap(gotype) size_t, const size_t & %{int64%}
+
+%typemap(in) size_t
+%{ $1 = (size_t)$input; %}
+
+%typemap(in) const size_t &
+%{ $1 = ($1_ltype)&$input; %}
+
+%typemap(out) size_t
+%{ $result = $1; %}
+
+%typemap(goout) size_t ""
+
+%typemap(out) const size_t &
+%{ $result = ($*1_ltype)*$1; %}
+
+%typemap(goout) const size_t & ""
+
+%typemap(directorin) size_t
+%{ $input = (size_t)$1; %}
+
+%typemap(godirectorin) size_t ""
+
+%typemap(directorin) const size_t &
+%{ $input = ($*1_ltype)$1; %}
+
+%typemap(godirectorin) const size_t & ""
+
+%typemap(directorout) size_t
+%{ $result = ($1_ltype)$input; %}
+
+%typemap(directorout,warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) const size_t &
+%{
+  $result = new $*1_ltype($input);
+  swig_acquire_pointer(&swig_mem, $result);
+%}
+
+/* Member pointers.  */
+
+%typemap(gotype) SWIGTYPE (CLASS::*)
+%{$gotypename%}
+
+%typemap(in) SWIGTYPE (CLASS::*)
+%{ $1 = *($&1_ltype)$input; %}
+
+%typemap(out) SWIGTYPE (CLASS::*)
+%{
+  struct swig_out_type { intgo size; void* val; } *swig_out;
+  swig_out = (struct swig_out_type*)malloc(sizeof(*swig_out));
+  if (swig_out) {
+    swig_out->size = sizeof($1_ltype);
+    swig_out->val = malloc(swig_out->size);
+    if (swig_out->val) {
+      *($&1_ltype)(swig_out->val) = $1;
+    }
+  }
+  $result = swig_out;
+%}
+
+%typemap(goout) SWIGTYPE (CLASS::*)
+%{
+  {
+    type swig_out_type struct { size int; val uintptr }
+    p := (*swig_out_type)(unsafe.Pointer($1))
+    if p == nil || p.val == 0 {
+      $result = nil
+    } else {
+      m := make([]byte, p.size)
+      a := (*[1024]byte)(unsafe.Pointer(p.val))[:p.size]
+      copy(m, a)
+      Swig_free(p.val)
+      Swig_free(uintptr(unsafe.Pointer(p)))
+      $result = &m[0]
+    }
+  }
+%}
+
+%typemap(directorin) SWIGTYPE (CLASS::*)
+%{ $input = *($&1_ltype)$1; %}
+
+%typemap(godirectorin) SWIGTYPE (CLASS::*) ""
+
+%typemap(directorout) SWIGTYPE (CLASS::*)
+%{
+  $result = new $1_ltype($input);
+  swig_acquire_pointer(&swig_mem, $result);
+%}
+
+/* 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_ltype)$1; %}
+
+%typemap(goout) SWIGTYPE * ""
+
+%typemap(directorin) SWIGTYPE *
+%{ *($&1_ltype)&$input = ($1_ltype)$1; %}
+
+%typemap(godirectorin) SWIGTYPE * ""
+
+%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; %}
+
+%typemap(goout) SWIGTYPE *const& ""
+
+/* 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(goout) SWIGTYPE & ""
+
+%typemap(directorin) SWIGTYPE &
+%{ $input = ($1_ltype)&$1; %}
+
+%typemap(godirectorin) SWIGTYPE & ""
+
+%typemap(directorout) SWIGTYPE &
+%{ *($&1_ltype)&$result = $input; %}
+
+%typemap(gotype) SWIGTYPE &&
+%{$gotypename%}
+
+%typemap(in) SWIGTYPE &&
+%{ $1 = *($&1_ltype)&$input; %}
+
+%typemap(out) SWIGTYPE &&
+%{ *($&1_ltype)&$result = $1; %}
+
+%typemap(goout) SWIGTYPE && ""
+
+%typemap(directorin) SWIGTYPE &&
+%{ $input = ($1_ltype)&$1_name; %}
+
+%typemap(godirectorin) SWIGTYPE && ""
+
+%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(goout) SWIGTYPE [] ""
+
+%typemap(directorin) SWIGTYPE []
+%{ $input = *($1_ltype)&$1; %}
+
+%typemap(godirectorin) SWIGTYPE [] ""
+
+%typemap(directorout) SWIGTYPE []
+%{ *($&1_ltype)&$result = $input; %}
+
+/* Strings.  */
+
+%typemap(gotype)
+	char *, char *&, char[ANY], 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[]
+%{
+  $1 = ($1_ltype)malloc($input.n + 1);
+  memcpy($1, $input.p, $input.n);
+  $1[$input.n] = '\0';
+%}
+
+%typemap(in) char *& (char *temp)
+%{
+  temp = (char *)malloc($input.n + 1);
+  memcpy(temp, $input.p, $input.n);
+  temp[$input.n] = '\0';
+  $1 = ($1_ltype)&temp;
+%}
+
+%typemap(freearg)
+	char *, char *&, char[ANY], char[]
+%{ free($1); %}
+
+%typemap(out,fragment="AllocateString")
+	char *, char *&, char[ANY], char[]
+%{ $result = Swig_AllocateString((char*)$1, $1 ? strlen((char*)$1) : 0); %}
+
+%typemap(goout,fragment="CopyString")
+	char *, char *&, char[ANY], char[]
+%{ $result = swigCopyString($1) %}
+
+%typemap(directorin,fragment="AllocateString")
+	char *, char *&, char[ANY], char[]
+%{
+  $input = Swig_AllocateString((char*)$1, $1 ? strlen((char*)$1) : 0);
+%}
+
+%typemap(godirectorin,fragment="CopyString")
+	char *, char *&, char[ANY], char[]
+%{
+  $result = swigCopyString($input)
+%}
+
+%typemap(godirectorout)
+	char *, char *&, char[ANY], char[]
+%{
+  {
+    p := Swig_malloc(len($input) + 1)
+    s := (*[1<<30]byte)(unsafe.Pointer(p))[:len($input) + 1]
+    copy(s, $input)
+    s[len($input)] = 0
+    $result = *(*string)(unsafe.Pointer(&s))
+  }
+%}
+
+%typemap(directorout, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG)
+	char *, char *&, char[ANY], 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,fragment="AllocateString") (char *STRING, size_t LENGTH)
+%{ $result = Swig_AllocateString((char*)$1, (size_t)$2); %}
+
+%typemap(goout,fragment="CopyString") (char *STRING, size_t LENGTH)
+%{ $result = swigCopyString($1) %}
+
+%typemap(directorin,fragment="AllocateString") (char *STRING, size_t LENGTH)
+%{ $input = Swig_AllocateString((char*)$1, $2); %}
+
+%typemap(godirectorin,fragment="CopyString") (char *STRING, size_t LENGTH)
+%{ $result = swigCopyString($input) %}
+
+%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(goout) enum SWIGTYPE ""
+
+%typemap(directorin) enum SWIGTYPE
+%{ $input = (intgo)$1; %}
+
+%typemap(godirectorin) enum SWIGTYPE ""
+
+%typemap(directorout) enum SWIGTYPE
+%{ $result = ($1_ltype)$input; %}
+
+%typemap(directorin) enum SWIGTYPE & (intgo e)
+%{
+  e = (intgo)$1;
+  $input = ($1_ltype)&e;
+%}
+
+%typemap(godirectorin) enum SWIGTYPE & ""
+
+%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(goout) SWIGTYPE ""
+
+%typemap(directorin) SWIGTYPE
+%{ $input = new $1_ltype((const $1_ltype &)$1); %}
+
+%typemap(godirectorin) SWIGTYPE ""
+
+%typemap(directorout) SWIGTYPE
+%{ $result = *($&1_ltype)$input; %}
+
+/* Exception handling */
+
+%typemap(throws) char *
+%{ _swig_gopanic($1); %}
+
+%typemap(throws) SWIGTYPE, 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 &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT64) /* Go int64 */
+    long, 
+    const long &, 
+    long long,
+    const long long &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT64) /* Go uint64 */
+    unsigned long, 
+    const unsigned long &, 
+    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 &&,
+    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/3.0.12/go/gokw.swg
index dd9f35a..dd9f35a 100644
--- a/share/swig/2.0.11/go/gokw.swg
+++ b/share/swig/3.0.12/go/gokw.swg
diff --git a/share/swig/3.0.12/go/goruntime.swg b/share/swig/3.0.12/go/goruntime.swg
new file mode 100644
index 0000000..dc6193d
--- /dev/null
+++ b/share/swig/3.0.12/go/goruntime.swg
@@ -0,0 +1,471 @@
+/* ------------------------------------------------------------
+ * goruntime.swg
+ *
+ * Go runtime code for the various generated files.
+ * ------------------------------------------------------------ */
+
+%inline %{
+static void Swig_free(void* p) {
+  free(p);
+}
+
+static void* Swig_malloc(int c) {
+  return malloc(c);
+}
+%}
+
+%insert(runtime) %{
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+
+%}
+
+#if SWIGGO_CGO
+%insert(cgo_comment_typedefs) %{
+#include <stdint.h>
+%}
+#endif
+
+#if SWIGGO_INTGO_SIZE == 32
+%insert(runtime) %{
+typedef int intgo;
+typedef unsigned int uintgo;
+%}
+#if SWIGGO_CGO
+%insert(cgo_comment_typedefs) %{
+typedef int intgo;
+typedef unsigned int uintgo;
+%}
+#endif
+#elif SWIGGO_INTGO_SIZE == 64
+%insert(runtime) %{
+typedef long long intgo;
+typedef unsigned long long uintgo;
+%}
+#if SWIGGO_CGO
+%insert(cgo_comment_typedefs) %{
+typedef long long intgo;
+typedef unsigned long long uintgo;
+%}
+#endif
+#else
+%insert(runtime) %{
+typedef ptrdiff_t intgo;
+typedef size_t uintgo;
+%}
+#if SWIGGO_CGO
+%insert(cgo_comment_typedefs) %{
+typedef ptrdiff_t intgo;
+typedef size_t uintgo;
+%}
+#endif
+#endif
+
+#ifndef SWIGGO_GCCGO
+// Set the host compiler struct attribute that will be
+// used to match gc's struct layout. For example, on 386 Windows,
+// gcc wants to 8-align int64s, but gc does not.
+// Use __gcc_struct__ to work around http://gcc.gnu.org/PR52991 on x86,
+// and https://golang.org/issue/5603.
+// See: https://github.com/golang/go/blob/fcbf04f9b93b4cd8addd05c2ed784118eb50a46c/src/cmd/cgo/out.go#L663
+%insert(runtime) %{
+# if !defined(__clang__) && (defined(__i386__) || defined(__x86_64__))
+#   define SWIGSTRUCTPACKED __attribute__((__packed__, __gcc_struct__))
+# else
+#   define SWIGSTRUCTPACKED __attribute__((__packed__))
+# endif
+%}
+#else
+# define SWIGSTRUCTPACKED
+#endif
+
+%insert(runtime) %{
+
+typedef struct { char *p; intgo n; } _gostring_;
+typedef struct { void* array; intgo len; intgo cap; } _goslice_;
+
+%}
+
+#ifdef SWIGGO_CGO
+
+%insert(cgo_comment_typedefs) %{
+
+typedef struct { char *p; intgo n; } _gostring_;
+typedef struct { void* array; intgo len; intgo cap; } _goslice_;
+
+%}
+
+#endif
+
+#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 char* _cgo_topofstack(void) __attribute__ ((weak));
+extern void _cgo_allocate(void *, int);
+extern void _cgo_panic(void *, int);
+#ifdef __cplusplus
+}
+#endif
+
+static char *_swig_topofstack() {
+  if (_cgo_topofstack) {
+    return _cgo_topofstack();
+  } else {
+    return 0;
+  }
+}
+
+static void _swig_gopanic(const char *p) {
+  struct {
+    const char *p;
+  } SWIGSTRUCTPACKED a;
+  a.p = p;
+  crosscall2(_cgo_panic, &a, (int) sizeof a);
+}
+
+%}
+
+#if !SWIGGO_CGO
+
+/* This is here for backward compatibility, but it will not work
+   with Go 1.5 or later.  Do not use it in new code.  */
+%insert(runtime) %{
+
+static void *_swig_goallocate(size_t len) {
+  struct {
+    size_t len;
+    void *ret;
+  } SWIGSTRUCTPACKED a;
+  a.len = len;
+  crosscall2(_cgo_allocate, &a, (int) sizeof a);
+  return a.ret;
+}
+
+%}
+
+#endif
+
+#if !SWIGGO_CGO
+
+/* Boilerplate for C code when using 6g/8g.  This code is compiled
+   with 6c/8c.  */
+%insert(gc_header) %{
+#include "runtime.h"
+#include "cgocall.h"
+
+#pragma dataflag 16
+static void *cgocall = runtime·cgocall;
+#pragma dataflag 16
+void *·_cgo_runtime_cgocall = &cgocall;
+
+%}
+
+#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 *);
+#ifdef __cplusplus
+}
+#endif
+
+#define _swig_goallocate _cgo_allocate
+#define _swig_gopanic _cgo_panic
+%}
+
+#if !SWIGGO_CGO
+
+%insert(runtime) %{
+
+/* 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.  */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SWIG_GCC_VERSION \
+  (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+
+#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
+
+#define SWIGSTRINGIFY2(s) #s
+#define SWIGSTRINGIFY(s) SWIGSTRINGIFY2(s)
+
+void SwigCgocall()
+  __asm__(SWIGSTRINGIFY(SWIGGO_PREFIX) ".SwigCgocall");
+void SwigCgocall() {
+  SwigDoCgocall();
+}
+
+void SwigCgocallDone()
+  __asm__(SWIGSTRINGIFY(SWIGGO_PREFIX) ".SwigCgocallDone");
+void SwigCgocallDone() {
+  SwigDoCgocallDone();
+}
+
+void SwigCgocallBack()
+  __asm__(SWIGSTRINGIFY(SWIGGO_PREFIX) ".SwigCgocallBack");
+void SwigCgocallBack() {
+  SwigDoCgocallBack();
+}
+
+void SwigCgocallBackDone()
+  __asm__(SWIGSTRINGIFY(SWIGGO_PREFIX) ".SwigCgocallBackDone");
+void SwigCgocallBackDone() {
+  SwigDoCgocallBackDone();
+}
+
+#undef SWIGSTRINGIFY
+#undef SWIGSTRINGIFY2
+
+#ifdef __cplusplus
+}
+#endif
+
+%}
+
+#endif
+
+#endif
+
+#if !SWIGGO_CGO
+
+%insert(runtime) %{
+
+/* This is here for backward compatibility, but it will not work
+   with Go 1.5 or later.  Do not use it in new code.  */
+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;
+}
+
+%}
+
+#endif
+
+%insert(runtime) %{
+
+#define SWIG_contract_assert(expr, msg) \
+  if (!(expr)) { _swig_gopanic(msg); } else
+%}
+
+#ifndef SWIGGO_GCCGO
+
+%go_import("unsafe", _ "runtime/cgo")
+
+#if !SWIGGO_CGO
+%insert(go_header) %{
+var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
+%}
+#endif
+
+#else
+
+%go_import("syscall", "unsafe")
+
+%insert(go_header) %{
+
+type _ syscall.Sockaddr
+
+%}
+
+#endif
+
+%insert(go_header) %{
+
+type _ unsafe.Pointer
+
+%}
+
+/* Swig_always_false is used to conditionally assign parameters to
+   Swig_escape_val so that the compiler thinks that they escape.  We
+   only assign them if Swig_always_false is true, which it never is.
+   We export the variable so that the compiler doesn't realize that it
+   is never set. */
+%insert(go_header) %{
+var Swig_escape_always_false bool
+var Swig_escape_val interface{}
+%}
+
+/* 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
+%}
+
+/* Handle memory management for directors.  */
+
+%insert(director) %{
+#include <map>
+
+namespace {
+  struct GCItem {
+    virtual ~GCItem() {}
+  };
+
+  struct GCItem_var {
+    GCItem_var(GCItem *item = 0) : _item(item) {
+    }
+
+    GCItem_var& operator=(GCItem *item) {
+      GCItem *tmp = _item;
+      _item = item;
+      delete tmp;
+      return *this;
+    }
+
+    ~GCItem_var() {
+      delete _item;
+    }
+
+    GCItem* operator->() {
+      return _item;
+    }
+
+    private:
+      GCItem *_item;
+  };
+
+  template <typename Type>
+  struct GCItem_T : GCItem {
+    GCItem_T(Type *ptr) : _ptr(ptr) {
+    }
+
+    virtual ~GCItem_T() {
+      delete _ptr;
+    }
+
+  private:
+    Type *_ptr;
+  };
+}
+
+class Swig_memory {
+public:
+  template <typename Type>
+  void swig_acquire_pointer(Type* vptr) {
+    if (vptr) {
+      swig_owner[vptr] = new GCItem_T<Type>(vptr);
+    }
+  }
+private:
+  typedef std::map<void *, GCItem_var> swig_ownership_map;
+  swig_ownership_map swig_owner;
+};
+
+template <typename Type>
+static void swig_acquire_pointer(Swig_memory** pmem, Type* ptr) {
+  if (!pmem) {
+    *pmem = new Swig_memory;
+  }
+  (*pmem)->swig_acquire_pointer(ptr);
+}
+%}
+
+/* For directors we need C++ to track a Go pointer.  Since we can't
+   pass a Go pointer into C++, we use a map to track the pointers on
+   the Go side.  */
+
+%go_import("sync")
+
+%insert(go_header) %{
+type _ sync.Mutex
+%}
+
+%insert(go_director) %{
+
+var swigDirectorTrack struct {
+	sync.Mutex
+	m map[int]interface{}
+	c int
+}
+
+func swigDirectorAdd(v interface{}) int {
+	swigDirectorTrack.Lock()
+	defer swigDirectorTrack.Unlock()
+	if swigDirectorTrack.m == nil {
+		swigDirectorTrack.m = make(map[int]interface{})
+	}
+	swigDirectorTrack.c++
+	ret := swigDirectorTrack.c
+	swigDirectorTrack.m[ret] = v
+	return ret
+}
+
+func swigDirectorLookup(c int) interface{} {
+	swigDirectorTrack.Lock()
+	defer swigDirectorTrack.Unlock()
+	ret := swigDirectorTrack.m[c]
+	if ret == nil {
+		panic("C++ director pointer not found (possible	use-after-free)")
+	}
+	return ret
+}
+
+func swigDirectorDelete(c int) {
+	swigDirectorTrack.Lock()
+	defer swigDirectorTrack.Unlock()
+	if swigDirectorTrack.m[c] == nil {
+		if c > swigDirectorTrack.c {
+			panic("C++ director pointer invalid (possible memory corruption")
+		} else {
+			panic("C++ director pointer not found (possible use-after-free)")
+		}
+	}
+	delete(swigDirectorTrack.m, c)
+}
+
+%}
diff --git a/share/swig/3.0.12/go/gostring.swg b/share/swig/3.0.12/go/gostring.swg
new file mode 100644
index 0000000..44cbbb8
--- /dev/null
+++ b/share/swig/3.0.12/go/gostring.swg
@@ -0,0 +1,29 @@
+/* ------------------------------------------------------------
+ * gostring.swg
+ *
+ * Support for returning strings from C to Go.
+ * ------------------------------------------------------------ */
+
+// C/C++ code to convert a memory buffer into a Go string allocated in
+// C/C++ memory.
+%fragment("AllocateString", "runtime") %{
+static _gostring_ Swig_AllocateString(const char *p, size_t l) {
+  _gostring_ ret;
+  ret.p = (char*)malloc(l);
+  memcpy(ret.p, p, l);
+  ret.n = l;
+  return ret;
+}
+%}
+
+// Go code to convert a string allocated in C++ memory to one
+// allocated in Go memory.
+%fragment("CopyString", "go_runtime") %{
+type swig_gostring struct { p uintptr; n int }
+func swigCopyString(s string) string {
+  p := *(*swig_gostring)(unsafe.Pointer(&s))
+  r := string((*[0x7fffffff]byte)(unsafe.Pointer(p.p))[:p.n])
+  Swig_free(p.p)
+  return r
+}
+%}
diff --git a/share/swig/2.0.11/go/std_common.i b/share/swig/3.0.12/go/std_common.i
index c010fac..c010fac 100644
--- a/share/swig/2.0.11/go/std_common.i
+++ b/share/swig/3.0.12/go/std_common.i
diff --git a/share/swig/2.0.11/go/std_deque.i b/share/swig/3.0.12/go/std_deque.i
index cb98f6c..cb98f6c 100644
--- a/share/swig/2.0.11/go/std_deque.i
+++ b/share/swig/3.0.12/go/std_deque.i
diff --git a/share/swig/3.0.12/go/std_except.i b/share/swig/3.0.12/go/std_except.i
new file mode 100644
index 0000000..4f021a1
--- /dev/null
+++ b/share/swig/3.0.12/go/std_except.i
@@ -0,0 +1,31 @@
+/* -----------------------------------------------------------------------------
+ * 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 <typeinfo>
+#include <stdexcept>
+%}
+
+namespace std 
+{
+  %ignore exception;
+  struct exception {};
+}
+
+%typemap(throws) std::bad_cast		%{_swig_gopanic($1.what());%}
+%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/3.0.12/go/std_list.i
index e026233..e026233 100644
--- a/share/swig/2.0.11/go/std_list.i
+++ b/share/swig/3.0.12/go/std_list.i
diff --git a/share/swig/2.0.11/go/std_map.i b/share/swig/3.0.12/go/std_map.i
index 84b0c74..84b0c74 100644
--- a/share/swig/2.0.11/go/std_map.i
+++ b/share/swig/3.0.12/go/std_map.i
diff --git a/share/swig/2.0.11/go/std_pair.i b/share/swig/3.0.12/go/std_pair.i
index fe45ee6..fe45ee6 100644
--- a/share/swig/2.0.11/go/std_pair.i
+++ b/share/swig/3.0.12/go/std_pair.i
diff --git a/share/swig/3.0.12/go/std_string.i b/share/swig/3.0.12/go/std_string.i
new file mode 100644
index 0000000..099ae84
--- /dev/null
+++ b/share/swig/3.0.12/go/std_string.i
@@ -0,0 +1,91 @@
+/* -----------------------------------------------------------------------------
+ * 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(godirectorout) string
+%{
+  {
+    p := Swig_malloc(len($input))
+    s := (*[1<<30]byte)(unsafe.Pointer(p))[:len($input)]
+    copy(s, $input)
+    $result = *(*string)(unsafe.Pointer(&s))
+  }
+%}
+
+%typemap(directorout) string
+%{
+  $result.assign($input.p, $input.n);
+  free($input.p);
+%}
+
+%typemap(out,fragment="AllocateString") string
+%{ $result = Swig_AllocateString($1.data(), $1.length()); %}
+
+%typemap(goout,fragment="CopyString") string
+%{ $result = swigCopyString($1) %}
+
+%typemap(directorin,fragment="AllocateString") string
+%{ $input = Swig_AllocateString($1.data(), $1.length()); %}
+
+%typemap(godirectorin,fragment="CopyString") string
+%{ $result = swigCopyString($input) %}
+
+%typemap(in) const string &
+%{
+  $*1_ltype $1_str($input.p, $input.n);
+  $1 = &$1_str;
+%}
+
+%typemap(godirectorout) const string &
+%{
+  {
+    p := Swig_malloc(len($input))
+    s := (*[1<<30]byte)(unsafe.Pointer(p))[:len($input)]
+    copy(s, $input)
+    $result = *(*string)(unsafe.Pointer(&s))
+  }
+%}
+
+%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const string &
+%{
+  static $*1_ltype $1_str;
+  $1_str.assign($input.p, $input.n);
+  free($input.p);
+  $result = &$1_str;
+%}
+
+%typemap(out,fragment="AllocateString") const string &
+%{ $result = Swig_AllocateString((*$1).data(), (*$1).length()); %}
+
+%typemap(goout,fragment="CopyString") const string &
+%{ $result = swigCopyString($1) %}
+
+%typemap(directorin,fragment="AllocateString") const string &
+%{ $input = Swig_AllocateString($1.data(), $1.length()); %}
+
+%typemap(godirectorin,fragment="CopyString") const string &
+%{ $result = swigCopyString($input) %}
+
+}
diff --git a/share/swig/3.0.12/go/std_vector.i b/share/swig/3.0.12/go/std_vector.i
new file mode 100644
index 0000000..29bcd13
--- /dev/null
+++ b/share/swig/3.0.12/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 {
+            bool 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/3.0.12/go/stl.i
index 38aba67..38aba67 100644
--- a/share/swig/2.0.11/go/stl.i
+++ b/share/swig/3.0.12/go/stl.i
diff --git a/share/swig/3.0.12/go/typemaps.i b/share/swig/3.0.12/go/typemaps.i
new file mode 100644
index 0000000..d2e60d3
--- /dev/null
+++ b/share/swig/3.0.12/go/typemaps.i
@@ -0,0 +1,298 @@
+/* -----------------------------------------------------------------------------
+ * 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(goout) 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(goout) TYPE *INPUT, TYPE &INPUT ""
+
+%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(goout) 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_TYPEMAP(long, int64);
+INOUT_TYPEMAP(unsigned long, uint64);
+INOUT_TYPEMAP(long long, int64);
+INOUT_TYPEMAP(unsigned long long, uint64);
+INOUT_TYPEMAP(float, float32);
+INOUT_TYPEMAP(double, float64);
+
+#undef INOUT_TYPEMAP
diff --git a/share/swig/2.0.11/guile/common.scm b/share/swig/3.0.12/guile/common.scm
index 17c9ab5..17c9ab5 100644
--- a/share/swig/2.0.11/guile/common.scm
+++ b/share/swig/3.0.12/guile/common.scm
diff --git a/share/swig/2.0.11/guile/cplusplus.i b/share/swig/3.0.12/guile/cplusplus.i
index d5d65ef..d5d65ef 100644
--- a/share/swig/2.0.11/guile/cplusplus.i
+++ b/share/swig/3.0.12/guile/cplusplus.i
diff --git a/share/swig/2.0.11/guile/guile.i b/share/swig/3.0.12/guile/guile.i
index ef270d7..ef270d7 100644
--- a/share/swig/2.0.11/guile/guile.i
+++ b/share/swig/3.0.12/guile/guile.i
diff --git a/share/swig/2.0.11/guile/guile_scm.swg b/share/swig/3.0.12/guile/guile_scm.swg
index dfd5da2..dfd5da2 100644
--- a/share/swig/2.0.11/guile/guile_scm.swg
+++ b/share/swig/3.0.12/guile/guile_scm.swg
diff --git a/share/swig/3.0.12/guile/guile_scm_run.swg b/share/swig/3.0.12/guile/guile_scm_run.swg
new file mode 100644
index 0000000..1cc08b0
--- /dev/null
+++ b/share/swig/3.0.12/guile/guile_scm_run.swg
@@ -0,0 +1,495 @@
+/* -----------------------------------------------------------------------------
+ * guile_scm_run.swg
+ * ----------------------------------------------------------------------------- */
+
+#include <libguile.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* In the code below, use guile 2.0 compatible functions where possible.
+   Functions that don't exist in older versions will be mapped to
+   a deprecated equivalent for those versions only */
+#if defined (SCM_MAJOR_VERSION) && (SCM_MAJOR_VERSION < 2)
+
+static SCM
+scm_module_variable (SCM module, SCM sym)
+{
+  return scm_sym2var (sym, scm_module_lookup_closure (module), SCM_BOOL_F);
+}
+
+#endif
+
+#if SCM_MAJOR_VERSION >= 2
+/* scm_c_define_gsubr takes a different parameter type depending on the guile version */
+
+typedef scm_t_subr swig_guile_proc;
+#else
+typedef SCM (*swig_guile_proc)();
+#endif
+typedef SCM (*guile_destructor)(SCM);
+
+typedef struct swig_guile_clientdata {
+  guile_destructor destroy;
+  SCM goops_class;
+} swig_guile_clientdata;
+
+#if SCM_MAJOR_VERSION <= 2
+#define scm_to_utf8_string scm_to_locale_string
+#define scm_from_utf8_string scm_from_locale_string
+#endif
+#define SWIG_scm2str(s) \
+  SWIG_Guile_scm2newstr(s, NULL)
+#define SWIG_str02scm(str) \
+  str ? scm_from_utf8_string(str) : SCM_BOOL_F 
+# define SWIG_malloc(size) \
+  scm_malloc(size)
+# define SWIG_free(mem) \
+  free(mem)
+#define SWIG_ConvertPtr(s, result, type, flags) \
+  SWIG_Guile_ConvertPtr(s, result, type, flags)
+#define SWIG_MustGetPtr(s, type, argnum, flags) \
+  SWIG_Guile_MustGetPtr(s, type, argnum, flags, FUNC_NAME)
+#define SWIG_NewPointerObj(ptr, type, owner) \
+  SWIG_Guile_NewPointerObj((void*)ptr, type, owner)
+#define SWIG_PointerAddress(object) \
+  SWIG_Guile_PointerAddress(object)
+#define SWIG_PointerType(object) \
+  SWIG_Guile_PointerType(object)
+#define SWIG_IsPointerOfType(object, type) \
+  SWIG_Guile_IsPointerOfType(object, type)
+#define SWIG_IsPointer(object) \
+  SWIG_Guile_IsPointer(object)
+#define SWIG_contract_assert(expr, msg)				\
+  if (!(expr))							\
+    scm_error(scm_from_locale_symbol("swig-contract-assertion-failed"),	\
+	      (char *) FUNC_NAME, (char *) msg,			\
+	      SCM_EOL, SCM_BOOL_F); else
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty) \
+  SWIG_Guile_ConvertMember(obj, ptr, sz, ty, FUNC_NAME)
+#define SWIG_NewMemberObj(ptr, sz, type) \
+  SWIG_Guile_NewMemberObj(ptr, sz, type, FUNC_NAME)
+  
+/* Runtime API */
+static swig_module_info *SWIG_Guile_GetModule(void *SWIGUNUSEDPARM(clientdata));
+#define SWIG_GetModule(clientdata) SWIG_Guile_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) SWIG_Guile_SetModule(pointer)
+  
+SWIGINTERN char *
+SWIG_Guile_scm2newstr(SCM str, size_t *len) {
+#define FUNC_NAME "SWIG_Guile_scm2newstr"
+  char *ret;
+
+  SCM_ASSERT (scm_is_string(str), str, 1, FUNC_NAME);
+
+  ret = scm_to_utf8_string(str);
+  if (!ret) return NULL;
+
+  if (len) *len = strlen(ret) - 1;
+  return ret;
+#undef FUNC_NAME
+}
+
+static int swig_initialized = 0;
+static scm_t_bits swig_tag = 0;
+static scm_t_bits swig_collectable_tag = 0;
+static scm_t_bits swig_destroyed_tag = 0;
+static scm_t_bits swig_member_function_tag = 0;
+static SCM swig_make_func = SCM_EOL;
+static SCM swig_keyword = SCM_EOL;
+static SCM swig_symbol = SCM_EOL;
+
+#define SWIG_Guile_GetSmob(x) \
+  ( !scm_is_null(x) && SCM_INSTANCEP(x) && scm_is_true(scm_slot_exists_p(x, swig_symbol)) \
+      ? scm_slot_ref(x, swig_symbol) : (x) )
+
+SWIGINTERN SCM
+SWIG_Guile_NewPointerObj(void *ptr, swig_type_info *type, int owner)
+{
+  if (ptr == NULL)
+    return SCM_EOL;
+  else {
+    SCM smob;
+    swig_guile_clientdata *cdata = (swig_guile_clientdata *) type->clientdata;
+    if (owner)
+      SCM_NEWSMOB2(smob, swig_collectable_tag, ptr, (void *) type);
+    else
+      SCM_NEWSMOB2(smob, swig_tag, ptr, (void *) type);
+
+    if (!cdata || SCM_NULLP(cdata->goops_class) || swig_make_func == SCM_EOL ) {
+      return smob;
+    } else {
+      /* the scm_make() C function only handles the creation of gf,
+	 methods and classes (no instances) the (make ...) function is
+	 later redefined in goops.scm.  So we need to call that
+	 Scheme function. */
+      return scm_apply(swig_make_func,
+		       scm_list_3(cdata->goops_class,
+				  swig_keyword,
+				  smob),
+		       SCM_EOL);
+    }
+  }
+}
+
+SWIGINTERN unsigned long
+SWIG_Guile_PointerAddress(SCM object)
+{
+  SCM smob = SWIG_Guile_GetSmob(object);
+  if (SCM_NULLP(smob)) return 0;
+  else if (SCM_SMOB_PREDICATE(swig_tag, smob)
+	   || SCM_SMOB_PREDICATE(swig_collectable_tag, smob)
+	   || SCM_SMOB_PREDICATE(swig_destroyed_tag, smob)) {
+    return (unsigned long) (void *) SCM_CELL_WORD_1(smob);
+  }
+  else scm_wrong_type_arg("SWIG-Guile-PointerAddress", 1, object);
+}
+
+SWIGINTERN swig_type_info *
+SWIG_Guile_PointerType(SCM object)
+{
+  SCM smob = SWIG_Guile_GetSmob(object);
+  if (SCM_NULLP(smob)) return NULL;
+  else if (SCM_SMOB_PREDICATE(swig_tag, smob)
+	   || SCM_SMOB_PREDICATE(swig_collectable_tag, smob)
+	   || SCM_SMOB_PREDICATE(swig_destroyed_tag, smob)) {
+    return (swig_type_info *) SCM_CELL_WORD_2(smob);
+  }
+  else scm_wrong_type_arg("SWIG-Guile-PointerType", 1, object);
+}
+  
+SWIGINTERN int
+SWIG_Guile_ConvertPtr(SCM s, void **result, swig_type_info *type, int flags)
+{
+  swig_cast_info *cast;
+  swig_type_info *from;
+  SCM smob = SWIG_Guile_GetSmob(s);
+
+  if (SCM_NULLP(smob)) {
+    *result = NULL;
+    return SWIG_OK;
+#if SCM_MAJOR_VERSION >= 2
+  } else if (SCM_POINTER_P(s)) {
+    *result = SCM_POINTER_VALUE(s);
+    return SWIG_OK;
+#endif /* if SCM_MAJOR_VERSION >= 2 */
+  } else if (SCM_SMOB_PREDICATE(swig_tag, smob) || SCM_SMOB_PREDICATE(swig_collectable_tag, smob)) {
+    /* we do not accept smobs representing destroyed pointers */
+    from = (swig_type_info *) SCM_CELL_WORD_2(smob);
+    if (!from) return SWIG_ERROR;
+    if (type) {
+      cast = SWIG_TypeCheckStruct(from, type);
+      if (cast) {
+        int newmemory = 0;
+        *result = SWIG_TypeCast(cast, (void *) SCM_CELL_WORD_1(smob), &newmemory);
+        assert(!newmemory); /* newmemory handling not yet implemented */
+        return SWIG_OK;
+      } else {
+        return SWIG_ERROR;
+      }
+    } else {
+      *result = (void *) SCM_CELL_WORD_1(smob);
+      return SWIG_OK;
+    }
+  }
+  return SWIG_ERROR;
+}
+
+SWIGINTERNINLINE void *
+SWIG_Guile_MustGetPtr (SCM s, swig_type_info *type,
+		       int argnum, int flags, const char *func_name)
+{
+  void *result;
+  int res = SWIG_Guile_ConvertPtr(s, &result, type, flags);
+  if (!SWIG_IsOK(res)) {
+    /* type mismatch */
+    scm_wrong_type_arg((char *) func_name, argnum, s);
+  }
+  return result;
+}
+
+SWIGINTERNINLINE int
+SWIG_Guile_IsPointerOfType (SCM s, swig_type_info *type)
+{
+  void *result;
+  if (SWIG_Guile_ConvertPtr(s, &result, type, 0)) {
+    /* type mismatch */
+    return 0;
+  }
+  else return 1;
+}
+
+SWIGINTERNINLINE int
+SWIG_Guile_IsPointer (SCM s)
+{
+  /* module might not be initialized yet, so initialize it */
+  SWIG_GetModule(0);
+  return SWIG_Guile_IsPointerOfType (s, NULL);
+}
+
+/* Mark a pointer object non-collectable */
+SWIGINTERN void
+SWIG_Guile_MarkPointerNoncollectable(SCM s)
+{
+  SCM smob = SWIG_Guile_GetSmob(s);
+  if (!SCM_NULLP(smob)) {
+    if (SCM_SMOB_PREDICATE(swig_tag, smob) || SCM_SMOB_PREDICATE(swig_collectable_tag, smob)) {
+      SCM_SET_CELL_TYPE(smob, swig_tag);
+    }
+    else scm_wrong_type_arg(NULL, 0, s);
+  }
+}
+
+/* Mark a pointer object destroyed */
+SWIGINTERN void
+SWIG_Guile_MarkPointerDestroyed(SCM s)
+{
+  SCM smob = SWIG_Guile_GetSmob(s);
+  if (!SCM_NULLP(smob)) {
+    if (SCM_SMOB_PREDICATE(swig_tag, smob) || SCM_SMOB_PREDICATE(swig_collectable_tag, smob)) {
+      SCM_SET_CELL_TYPE(smob, swig_destroyed_tag);
+    }
+    else scm_wrong_type_arg(NULL, 0, s);
+  }
+}
+
+/* Member functions */
+
+SWIGINTERN SCM
+SWIG_Guile_NewMemberObj(void *ptr, size_t sz, swig_type_info *type,
+			const char *func_name)
+{
+  SCM smob;
+  void *copy = malloc(sz);
+  memcpy(copy, ptr, sz);
+  SCM_NEWSMOB2(smob, swig_member_function_tag, copy, (void *) type);
+  return smob;
+}
+
+SWIGINTERN int
+SWIG_Guile_ConvertMember(SCM smob, void *ptr, size_t sz, swig_type_info *type,
+			 const char *func_name)
+{
+  swig_cast_info *cast;
+  swig_type_info *from;
+
+  if (SCM_SMOB_PREDICATE(swig_member_function_tag, smob)) {
+    from = (swig_type_info *) SCM_CELL_WORD_2(smob);
+    if (!from) return SWIG_ERROR;
+    if (type) {
+      cast = SWIG_TypeCheckStruct(from, type);
+      if (!cast) return SWIG_ERROR;
+    }
+    memcpy(ptr, (void *) SCM_CELL_WORD_1(smob), sz);
+    return SWIG_OK;
+  }
+  return SWIG_ERROR;
+}
+     
+
+/* Init */
+
+SWIGINTERN int
+print_swig_aux (SCM swig_smob, SCM port, scm_print_state *pstate, 
+                const char *attribute)
+{
+  swig_type_info *type;
+  
+  type = (swig_type_info *) SCM_CELL_WORD_2(swig_smob);
+  if (type) {
+    scm_puts((char *) "#<", port);
+    scm_puts((char *) attribute, port);
+    scm_puts((char *) "swig-pointer ", port);
+    scm_puts((char *) SWIG_TypePrettyName(type), port);
+    scm_puts((char *) " ", port);
+    scm_intprint((long) SCM_CELL_WORD_1(swig_smob), 16, port);
+    scm_puts((char *) ">", port);
+    /* non-zero means success */
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+  
+SWIGINTERN int
+print_swig (SCM swig_smob, SCM port, scm_print_state *pstate)
+{
+  return print_swig_aux(swig_smob, port, pstate, "");
+}
+
+SWIGINTERN int
+print_collectable_swig (SCM swig_smob, SCM port, scm_print_state *pstate)
+{
+  return print_swig_aux(swig_smob, port, pstate, "collectable-");
+}
+
+SWIGINTERN int
+print_destroyed_swig (SCM swig_smob, SCM port, scm_print_state *pstate)
+{
+  return print_swig_aux(swig_smob, port, pstate, "destroyed-");
+}
+
+SWIGINTERN int
+print_member_function_swig (SCM swig_smob, SCM port, scm_print_state *pstate)
+{
+  swig_type_info *type;
+  type = (swig_type_info *) SCM_CELL_WORD_2(swig_smob);
+  if (type) {
+    scm_puts((char *) "#<", port);
+    scm_puts((char *) "swig-member-function-pointer ", port);
+    scm_puts((char *) SWIG_TypePrettyName(type), port);
+    scm_puts((char *) " >", port);
+    /* non-zero means success */
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+SWIGINTERN SCM
+equalp_swig (SCM A, SCM B)
+{
+  if (SCM_CELL_WORD_0(A) == SCM_CELL_WORD_0(B) && SCM_CELL_WORD_1(A) == SCM_CELL_WORD_1(B) 
+      && SCM_CELL_WORD_2(A) == SCM_CELL_WORD_2(B))
+    return SCM_BOOL_T;
+  else return SCM_BOOL_F;
+}
+
+SWIGINTERN size_t
+free_swig(SCM A)
+{
+  swig_type_info *type = (swig_type_info *) SCM_CELL_WORD_2(A);
+  if (type) {
+    if (type->clientdata && ((swig_guile_clientdata *)type->clientdata)->destroy)
+      ((swig_guile_clientdata *)type->clientdata)->destroy(A);
+  } 
+  return 0;
+}
+
+SWIGINTERN size_t
+free_swig_member_function(SCM A)
+{
+  free((swig_type_info *) SCM_CELL_WORD_1(A));
+  return 0;
+}
+
+SWIGINTERN int
+ensure_smob_tag(SCM swig_module,
+		scm_t_bits *tag_variable,
+		const char *smob_name,
+		const char *scheme_variable_name)
+{
+  SCM variable = scm_module_variable(swig_module,
+                             scm_from_locale_symbol(scheme_variable_name));
+  if (scm_is_false(variable)) {
+    *tag_variable = scm_make_smob_type((char*)scheme_variable_name, 0);
+    scm_c_module_define(swig_module, scheme_variable_name, 
+                        scm_from_ulong(*tag_variable));
+    return 1;
+  }
+  else {
+    *tag_variable = scm_to_ulong(SCM_VARIABLE_REF(variable));
+    return 0;
+  }
+}
+
+SWIGINTERN SCM
+SWIG_Guile_Init ()
+{
+  static SCM swig_module;
+  
+  if (swig_initialized) return swig_module;
+  swig_initialized = 1;
+
+  swig_module = scm_c_resolve_module("Swig swigrun");
+  if (ensure_smob_tag(swig_module, &swig_tag,
+		      "swig-pointer", "swig-pointer-tag")) {
+    scm_set_smob_print(swig_tag, print_swig);
+    scm_set_smob_equalp(swig_tag, equalp_swig);
+  }
+  if (ensure_smob_tag(swig_module, &swig_collectable_tag,
+		      "collectable-swig-pointer", "collectable-swig-pointer-tag")) {
+    scm_set_smob_print(swig_collectable_tag, print_collectable_swig);
+    scm_set_smob_equalp(swig_collectable_tag, equalp_swig);
+    scm_set_smob_free(swig_collectable_tag, free_swig);
+  }
+  if (ensure_smob_tag(swig_module, &swig_destroyed_tag,
+		      "destroyed-swig-pointer", "destroyed-swig-pointer-tag")) {
+    scm_set_smob_print(swig_destroyed_tag, print_destroyed_swig);
+    scm_set_smob_equalp(swig_destroyed_tag, equalp_swig);
+  }
+  if (ensure_smob_tag(swig_module, &swig_member_function_tag,
+		      "swig-member-function-pointer", "swig-member-function-pointer-tag")) {
+    scm_set_smob_print(swig_member_function_tag, print_member_function_swig);
+    scm_set_smob_free(swig_member_function_tag, free_swig_member_function);
+  }
+  swig_make_func = scm_permanent_object(
+  scm_variable_ref(scm_c_module_lookup(scm_c_resolve_module("oop goops"), "make")));
+  swig_keyword = scm_permanent_object(scm_from_locale_keyword((char*) "init-smob"));
+  swig_symbol = scm_permanent_object(scm_from_locale_symbol("swig-smob"));
+#ifdef SWIG_INIT_RUNTIME_MODULE
+  SWIG_INIT_RUNTIME_MODULE
+#endif
+
+  return swig_module;
+}
+
+SWIGINTERN swig_module_info *
+SWIG_Guile_GetModule(void *SWIGUNUSEDPARM(clientdata))
+{
+  SCM module = SWIG_Guile_Init();
+  SCM variable = scm_module_variable(module, scm_from_locale_symbol("swig-type-list-address" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME));
+  if (scm_is_false(variable)) {
+    return NULL;
+  } else {
+    return (swig_module_info *) scm_to_ulong(SCM_VARIABLE_REF(variable));
+  }
+}
+
+SWIGINTERN void
+SWIG_Guile_SetModule(swig_module_info *swig_module)
+{
+  SCM module = SWIG_Guile_Init();
+  scm_module_define(module,
+                    scm_from_locale_symbol("swig-type-list-address" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME),
+                    scm_from_ulong((unsigned long) swig_module));
+}
+
+SWIGINTERN int
+SWIG_Guile_GetArgs (SCM *dest, SCM rest,
+		    int reqargs, int optargs,
+		    const char *procname)
+{
+  int i;
+  int num_args_passed = 0;
+  for (i = 0; i<reqargs; i++) {
+    if (!SCM_CONSP(rest))
+      scm_wrong_num_args(scm_from_utf8_string(procname ? (char *) procname : "unknown procedure"));
+    *dest++ = SCM_CAR(rest);
+    rest = SCM_CDR(rest);
+    num_args_passed++;
+  }
+  for (i = 0; i<optargs && SCM_CONSP(rest); i++) {
+    *dest++ = SCM_CAR(rest);
+    rest = SCM_CDR(rest);
+    num_args_passed++;
+  }
+  for (; i<optargs; i++)
+    *dest++ = SCM_UNDEFINED;
+  if (!SCM_NULLP(rest))
+      scm_wrong_num_args(scm_from_utf8_string(procname ? (char *) procname : "unknown procedure"));
+  return num_args_passed;
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/share/swig/2.0.11/guile/guilemain.i b/share/swig/3.0.12/guile/guilemain.i
index 925b81f..925b81f 100644
--- a/share/swig/2.0.11/guile/guilemain.i
+++ b/share/swig/3.0.12/guile/guilemain.i
diff --git a/share/swig/2.0.11/guile/interpreter.i b/share/swig/3.0.12/guile/interpreter.i
index 524e069..524e069 100644
--- a/share/swig/2.0.11/guile/interpreter.i
+++ b/share/swig/3.0.12/guile/interpreter.i
diff --git a/share/swig/2.0.11/guile/list-vector.i b/share/swig/3.0.12/guile/list-vector.i
index 057a1da..057a1da 100644
--- a/share/swig/2.0.11/guile/list-vector.i
+++ b/share/swig/3.0.12/guile/list-vector.i
diff --git a/share/swig/2.0.11/guile/pointer-in-out.i b/share/swig/3.0.12/guile/pointer-in-out.i
index d8a631c..d8a631c 100644
--- a/share/swig/2.0.11/guile/pointer-in-out.i
+++ b/share/swig/3.0.12/guile/pointer-in-out.i
diff --git a/share/swig/2.0.11/guile/ports.i b/share/swig/3.0.12/guile/ports.i
index 7691d3e..7691d3e 100644
--- a/share/swig/2.0.11/guile/ports.i
+++ b/share/swig/3.0.12/guile/ports.i
diff --git a/share/swig/3.0.12/guile/std_common.i b/share/swig/3.0.12/guile/std_common.i
new file mode 100644
index 0000000..5899c55
--- /dev/null
+++ b/share/swig/3.0.12/guile/std_common.i
@@ -0,0 +1,25 @@
+/* -----------------------------------------------------------------------------
+ * std_common.i
+ *
+ * SWIG typemaps for STL - common utilities
+ * ----------------------------------------------------------------------------- */
+
+%include <std/std_except.i>
+
+%apply size_t { std::size_t };
+
+#define SWIG_bool2scm(b) scm_from_bool(b ? 1 : 0)
+#define SWIG_string2scm(s) SWIG_str02scm(s.c_str())
+
+%{
+#include <string>
+
+SWIGINTERNINLINE
+std::string SWIG_scm2string(SCM x) {
+    char* temp;
+    temp = SWIG_scm2str(x);
+    std::string s(temp);
+    if (temp) SWIG_free(temp);
+    return s;
+}
+%}
diff --git a/share/swig/2.0.11/guile/std_deque.i b/share/swig/3.0.12/guile/std_deque.i
index cb98f6c..cb98f6c 100644
--- a/share/swig/2.0.11/guile/std_deque.i
+++ b/share/swig/3.0.12/guile/std_deque.i
diff --git a/share/swig/3.0.12/guile/std_except.i b/share/swig/3.0.12/guile/std_except.i
new file mode 100644
index 0000000..6c30a31
--- /dev/null
+++ b/share/swig/3.0.12/guile/std_except.i
@@ -0,0 +1,13 @@
+// TODO: STL exception handling
+// Note that the generic std_except.i file did not work
+%{
+#include <typeinfo>
+#include <stdexcept>
+%}
+
+namespace std {
+  %ignore exception;
+  struct exception {
+  };
+}
+
diff --git a/share/swig/3.0.12/guile/std_map.i b/share/swig/3.0.12/guile/std_map.i
new file mode 100644
index 0000000..489acc1
--- /dev/null
+++ b/share/swig/3.0.12/guile/std_map.i
@@ -0,0 +1,1334 @@
+/* -----------------------------------------------------------------------------
+ * std_map.i
+ *
+ * SWIG typemaps for std::map
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+
+// ------------------------------------------------------------------------
+// std::map
+//
+// The aim of all that follows would be to integrate std::map with
+// Guile as much as possible, namely, to allow the user to pass and
+// be returned Scheme association lists.
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+//
+//   -- f(std::map<T>), f(const std::map<T>&), f(const std::map<T>*):
+//      the parameter being read-only, either a Scheme alist or a
+//      previously wrapped std::map<T> can be passed.
+//   -- f(std::map<T>&), f(std::map<T>*):
+//      the parameter must be modified; therefore, only a wrapped std::map
+//      can be passed.
+//   -- std::map<T> f():
+//      the map is returned by copy; therefore, a Scheme alist
+//      is returned which is most easily used in other Scheme functions
+//   -- std::map<T>& f(), std::map<T>* f(), const std::map<T>& f(),
+//      const std::map<T>* f():
+//      the map is returned by reference; therefore, a wrapped std::map
+//      is returned
+// ------------------------------------------------------------------------
+
+%{
+#include <map>
+#include <algorithm>
+#include <stdexcept>
+%}
+
+// exported class
+
+namespace std {
+
+    template<class K, class T> class map {
+        %typemap(in) map<K,T> {
+            if (scm_is_null($input)) {
+                $1 = std::map< K, T >();
+            } else if (scm_is_pair($input)) {
+                $1 = std::map< K, T >();
+                SCM alist = $input;
+                while (!scm_is_null(alist)) {
+                    K* k;
+                    T* x;
+                    SCM entry, key, val;
+                    entry = SCM_CAR(alist);
+                    if (!scm_is_pair(entry))
+                        SWIG_exception(SWIG_TypeError,"alist expected");
+                    key = SCM_CAR(entry);
+                    val = SCM_CDR(entry);
+                    k = (K*) SWIG_MustGetPtr(key,$descriptor(K *),$argnum, 0);
+                    if (SWIG_ConvertPtr(val,(void**) &x,
+                                    $descriptor(T *), 0) != 0) {
+                        if (!scm_is_pair(val))
+                            SWIG_exception(SWIG_TypeError,"alist expected");
+                        val = SCM_CAR(val);
+                        x = (T*) SWIG_MustGetPtr(val,$descriptor(T *),$argnum, 0);
+                    }
+                    (($1_type &)$1)[*k] = *x;
+                    alist = SCM_CDR(alist);
+                }
+            } else {
+                $1 = *(($&1_type)
+                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
+            }
+        }
+        %typemap(in) const map<K,T>& (std::map<K,T> temp),
+                     const map<K,T>* (std::map<K,T> temp) {
+            if (scm_is_null($input)) {
+                temp = std::map< K, T >();
+                $1 = &temp;
+            } else if (scm_is_pair($input)) {
+                temp = std::map< K, T >();
+                $1 = &temp;
+                SCM alist = $input;
+                while (!scm_is_null(alist)) {
+                    K* k;
+                    T* x;
+                    SCM entry, key, val;
+                    entry = SCM_CAR(alist);
+                    if (!scm_is_pair(entry))
+                        SWIG_exception(SWIG_TypeError,"alist expected");
+                    key = SCM_CAR(entry);
+                    val = SCM_CDR(entry);
+                    k = (K*) SWIG_MustGetPtr(key,$descriptor(K *),$argnum, 0);
+                    if (SWIG_ConvertPtr(val,(void**) &x,
+                                    $descriptor(T *), 0) != 0) {
+                        if (!scm_is_pair(val))
+                            SWIG_exception(SWIG_TypeError,"alist expected");
+                        val = SCM_CAR(val);
+                        x = (T*) SWIG_MustGetPtr(val,$descriptor(T *),$argnum, 0);
+                    }
+                    temp[*k] = *x;
+                    alist = SCM_CDR(alist);
+                }
+            } else {
+                $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
+            }
+        }
+        %typemap(out) map<K,T> {
+            SCM alist = SCM_EOL;
+            for (std::map< K, T >::reverse_iterator i=$i.rbegin(); i!=$i.rend(); ++i) {
+                K* key = new K(i->first);
+                T* val = new T(i->second);
+                SCM k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
+                SCM x = SWIG_NewPointerObj(val,$descriptor(T *), 1);
+                SCM entry = scm_cons(k,x);
+                alist = scm_cons(entry,alist);
+            }
+            $result = alist;
+        }
+        %typecheck(SWIG_TYPECHECK_MAP) map<K,T> {
+            /* native sequence? */
+            if (scm_is_null($input)) {
+                /* an empty sequence can be of any type */
+                $1 = 1;
+            } else if (scm_is_pair($input)) {
+                /* check the first element only */
+                K* k;
+                T* x;
+                SCM head = SCM_CAR($input);
+                if (scm_is_pair(head)) {
+                    SCM key = SCM_CAR(head);
+                    SCM val = SCM_CDR(head);
+                    if (SWIG_ConvertPtr(key,(void**) &k,
+                                    $descriptor(K *), 0) != 0) {
+                        $1 = 0;
+                    } else {
+                        if (SWIG_ConvertPtr(val,(void**) &x,
+                                        $descriptor(T *), 0) == 0) {
+                            $1 = 1;
+                        } else if (scm_is_pair(val)) {
+                            val = SCM_CAR(val);
+                            if (SWIG_ConvertPtr(val,(void**) &x,
+                                            $descriptor(T *), 0) == 0)
+                                $1 = 1;
+                            else
+                                $1 = 0;
+                        } else {
+                            $1 = 0;
+                        }
+                    }
+                } else {
+                    $1 = 0;
+                }
+            } else {
+                /* wrapped map? */
+                std::map< K, T >* m;
+                if (SWIG_ConvertPtr($input,(void **) &m,
+                                $&1_descriptor, 0) == 0)
+                    $1 = 1;
+                else
+                    $1 = 0;
+            }
+        }
+        %typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&,
+                                       const map<K,T>* {
+            /* native sequence? */
+            if (scm_is_null($input)) {
+                /* an empty sequence can be of any type */
+                $1 = 1;
+            } else if (scm_is_pair($input)) {
+                /* check the first element only */
+                K* k;
+                T* x;
+                SCM head = SCM_CAR($input);
+                if (scm_is_pair(head)) {
+                    SCM key = SCM_CAR(head);
+                    SCM val = SCM_CDR(head);
+                    if (SWIG_ConvertPtr(key,(void**) &k,
+                                    $descriptor(K *), 0) != 0) {
+                        $1 = 0;
+                    } else {
+                        if (SWIG_ConvertPtr(val,(void**) &x,
+                                        $descriptor(T *), 0) == 0) {
+                            $1 = 1;
+                        } else if (scm_is_pair(val)) {
+                            val = SCM_CAR(val);
+                            if (SWIG_ConvertPtr(val,(void**) &x,
+                                            $descriptor(T *), 0) == 0)
+                                $1 = 1;
+                            else
+                                $1 = 0;
+                        } else {
+                            $1 = 0;
+                        }
+                    }
+                } else {
+                    $1 = 0;
+                }
+            } else {
+                /* wrapped map? */
+                std::map< K, T >* m;
+                if (SWIG_ConvertPtr($input,(void **) &m,
+                                $1_descriptor, 0) == 0)
+                    $1 = 1;
+                else
+                    $1 = 0;
+            }
+        }
+        %rename("length") size;
+        %rename("null?") empty;
+        %rename("clear!") clear;
+        %rename("ref") __getitem__;
+        %rename("set!") __setitem__;
+        %rename("delete!") __delitem__;
+        %rename("has-key?") has_key;
+      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& __getitem__(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 __setitem__(const K& key, const T& x) {
+                (*self)[key] = x;
+            }
+            void __delitem__(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();
+            }
+            SCM keys() {
+                SCM result = SCM_EOL;
+                for (std::map< K, T >::reverse_iterator i=self->rbegin(); i!=self->rend(); ++i) {
+                    K* key = new K(i->first);
+                    SCM k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
+                    result = scm_cons(k,result);
+                }
+                return result;
+            }
+        }
+    };
+
+
+    // specializations for built-ins
+
+    %define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO)
+
+    template<class T> class map<K,T> {
+        %typemap(in) map<K,T> {
+            if (scm_is_null($input)) {
+                $1 = std::map< K, T >();
+            } else if (scm_is_pair($input)) {
+                $1 = std::map< K, T >();
+                SCM alist = $input;
+                while (!scm_is_null(alist)) {
+                    T* x;
+                    SCM entry, key, val;
+                    entry = SCM_CAR(alist);
+                    if (!scm_is_pair(entry))
+                        SWIG_exception(SWIG_TypeError,"alist expected");
+                    key = SCM_CAR(entry);
+                    val = SCM_CDR(entry);
+                    if (!CHECK(key))
+                        SWIG_exception(SWIG_TypeError,
+                                       "map<" #K "," #T "> expected");
+                    if (SWIG_ConvertPtr(val,(void**) &x,
+                                    $descriptor(T *), 0) != 0) {
+                        if (!scm_is_pair(val))
+                            SWIG_exception(SWIG_TypeError,"alist expected");
+                        val = SCM_CAR(val);
+                        x = (T*) SWIG_MustGetPtr(val,$descriptor(T *),$argnum, 0);
+                    }
+                    (($1_type &)$1)[CONVERT_FROM(key)] = *x;
+                    alist = SCM_CDR(alist);
+                }
+            } else {
+                $1 = *(($&1_type)
+                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
+            }
+        }
+        %typemap(in) const map<K,T>& (std::map<K,T> temp),
+                     const map<K,T>* (std::map<K,T> temp) {
+            if (scm_is_null($input)) {
+                temp = std::map< K, T >();
+                $1 = &temp;
+            } else if (scm_is_pair($input)) {
+                temp = std::map< K, T >();
+                $1 = &temp;
+                SCM alist = $input;
+                while (!scm_is_null(alist)) {
+                    T* x;
+                    SCM entry, key, val;
+                    entry = SCM_CAR(alist);
+                    if (!scm_is_pair(entry))
+                        SWIG_exception(SWIG_TypeError,"alist expected");
+                    key = SCM_CAR(entry);
+                    val = SCM_CDR(entry);
+                    if (!CHECK(key))
+                        SWIG_exception(SWIG_TypeError,
+                                       "map<" #K "," #T "> expected");
+                    if (SWIG_ConvertPtr(val,(void**) &x,
+                                    $descriptor(T *), 0) != 0) {
+                        if (!scm_is_pair(val))
+                            SWIG_exception(SWIG_TypeError,"alist expected");
+                        val = SCM_CAR(val);
+                        x = (T*) SWIG_MustGetPtr(val,$descriptor(T *),$argnum, 0);
+                    }
+                    temp[CONVERT_FROM(key)] = *x;
+                    alist = SCM_CDR(alist);
+                }
+            } else {
+                $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
+            }
+        }
+        %typemap(out) map<K,T> {
+            SCM alist = SCM_EOL;
+            for (std::map< K, T >::reverse_iterator i=$1.rbegin(); i!=$1.rend(); ++i) {
+                T* val = new T(i->second);
+                SCM k = CONVERT_TO(i->first);
+                SCM x = SWIG_NewPointerObj(val,$descriptor(T *), 1);
+                SCM entry = scm_cons(k,x);
+                alist = scm_cons(entry,alist);
+            }
+            $result = alist;
+        }
+        %typecheck(SWIG_TYPECHECK_MAP) map<K,T> {
+            // native sequence?
+            if (scm_is_null($input)) {
+                /* an empty sequence can be of any type */
+                $1 = 1;
+            } else if (scm_is_pair($input)) {
+                // check the first element only
+                T* x;
+                SCM head = SCM_CAR($input);
+                if (scm_is_pair(head)) {
+                    SCM key = SCM_CAR(head);
+                    SCM val = SCM_CDR(head);
+                    if (!CHECK(key)) {
+                        $1 = 0;
+                    } else {
+                        if (SWIG_ConvertPtr(val,(void**) &x,
+                                        $descriptor(T *), 0) == 0) {
+                            $1 = 1;
+                        } else if (scm_is_pair(val)) {
+                            val = SCM_CAR(val);
+                            if (SWIG_ConvertPtr(val,(void**) &x,
+                                            $descriptor(T *), 0) == 0)
+                                $1 = 1;
+                            else
+                                $1 = 0;
+                        } else {
+                            $1 = 0;
+                        }
+                    }
+                } else {
+                    $1 = 0;
+                }
+            } else {
+                // wrapped map?
+                std::map< K, T >* m;
+                if (SWIG_ConvertPtr($input,(void **) &m,
+                                $&1_descriptor, 0) == 0)
+                    $1 = 1;
+                else
+                    $1 = 0;
+            }
+        }
+        %typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&,
+                                       const map<K,T>* {
+            // native sequence?
+            if (scm_is_null($input)) {
+                /* an empty sequence can be of any type */
+                $1 = 1;
+            } else if (scm_is_pair($input)) {
+                // check the first element only
+                T* x;
+                SCM head = SCM_CAR($input);
+                if (scm_is_pair(head)) {
+                    SCM key = SCM_CAR(head);
+                    SCM val = SCM_CDR(head);
+                    if (!CHECK(key)) {
+                        $1 = 0;
+                    } else {
+                        if (SWIG_ConvertPtr(val,(void**) &x,
+                                        $descriptor(T *), 0) == 0) {
+                            $1 = 1;
+                        } else if (scm_is_pair(val)) {
+                            val = SCM_CAR(val);
+                            if (SWIG_ConvertPtr(val,(void**) &x,
+                                            $descriptor(T *), 0) == 0)
+                                $1 = 1;
+                            else
+                                $1 = 0;
+                        } else {
+                            $1 = 0;
+                        }
+                    }
+                } else {
+                    $1 = 0;
+                }
+            } else {
+                // wrapped map?
+                std::map< K, T >* m;
+                if (SWIG_ConvertPtr($input,(void **) &m,
+                                $1_descriptor, 0) == 0)
+                    $1 = 1;
+                else
+                    $1 = 0;
+            }
+        }
+        %rename("length") size;
+        %rename("null?") empty;
+        %rename("clear!") clear;
+        %rename("ref") __getitem__;
+        %rename("set!") __setitem__;
+        %rename("delete!") __delitem__;
+        %rename("has-key?") has_key;
+      public:
+        map();
+        map(const map< K, T > &);
+        
+        unsigned int size() const;
+        bool empty() const;
+        void clear();
+        %extend {
+            T& __getitem__(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 __setitem__(K key, const T& x) {
+                (*self)[key] = x;
+            }
+            void __delitem__(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(K key) {
+                std::map< K, T >::iterator i = self->find(key);
+                return i != self->end();
+            }
+            SCM keys() {
+                SCM result = SCM_EOL;
+                for (std::map< K, T >::reverse_iterator i=self->rbegin(); i!=self->rend(); ++i) {
+                    SCM k = CONVERT_TO(i->first);
+                    result = scm_cons(k,result);
+                }
+                return result;
+            }
+        }
+    };
+    %enddef
+
+    %define specialize_std_map_on_value(T,CHECK,CONVERT_FROM,CONVERT_TO)
+    template<class K> class map<K,T> {
+        %typemap(in) map<K,T> {
+            if (scm_is_null($input)) {
+                $1 = std::map< K, T >();
+            } else if (scm_is_pair($input)) {
+                $1 = std::map< K, T >();
+                SCM alist = $input;
+                while (!scm_is_null(alist)) {
+                    K* k;
+                    SCM entry, key, val;
+                    entry = SCM_CAR(alist);
+                    if (!scm_is_pair(entry))
+                        SWIG_exception(SWIG_TypeError,"alist expected");
+                    key = SCM_CAR(entry);
+                    val = SCM_CDR(entry);
+                    k = (K*) SWIG_MustGetPtr(key,$descriptor(K *),$argnum, 0);
+                    if (!CHECK(val)) {
+                        if (!scm_is_pair(val))
+                            SWIG_exception(SWIG_TypeError,"alist expected");
+                        val = SCM_CAR(val);
+                        if (!CHECK(val))
+                            SWIG_exception(SWIG_TypeError,
+                                           "map<" #K "," #T "> expected");
+                    }
+                    (($1_type &)$1)[*k] = CONVERT_FROM(val);
+                    alist = SCM_CDR(alist);
+                }
+            } else {
+                $1 = *(($&1_type)
+                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
+            }
+        }
+        %typemap(in) const map<K,T>& (std::map<K,T> temp),
+                     const map<K,T>* (std::map<K,T> temp) {
+            if (scm_is_null($input)) {
+                temp = std::map< K, T >();
+                $1 = &temp;
+            } else if (scm_is_pair($input)) {
+                temp = std::map< K, T >();
+                $1 = &temp;
+                SCM alist = $input;
+                while (!scm_is_null(alist)) {
+                    K* k;
+                    SCM entry, key, val;
+                    entry = SCM_CAR(alist);
+                    if (!scm_is_pair(entry))
+                        SWIG_exception(SWIG_TypeError,"alist expected");
+                    key = SCM_CAR(entry);
+                    val = SCM_CDR(entry);
+                    k = (K*) SWIG_MustGetPtr(key,$descriptor(K *),$argnum, 0);
+                    if (!CHECK(val)) {
+                        if (!scm_is_pair(val))
+                            SWIG_exception(SWIG_TypeError,"alist expected");
+                        val = SCM_CAR(val);
+                        if (!CHECK(val))
+                            SWIG_exception(SWIG_TypeError,
+                                           "map<" #K "," #T "> expected");
+                    }
+                    temp[*k] = CONVERT_FROM(val);
+                    alist = SCM_CDR(alist);
+                }
+            } else {
+                $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
+            }
+        }
+        %typemap(out) map<K,T> {
+            SCM alist = SCM_EOL;
+            for (std::map< K, T >::reverse_iterator i=$1.rbegin(); i!=$1.rend(); ++i) {
+                K* key = new K(i->first);
+                SCM k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
+                SCM x = CONVERT_TO(i->second);
+                SCM entry = scm_cons(k,x);
+                alist = scm_cons(entry,alist);
+            }
+            $result = alist;
+        }
+        %typecheck(SWIG_TYPECHECK_MAP) map<K,T> {
+            // native sequence?
+            if (scm_is_null($input)) {
+                /* an empty sequence can be of any type */
+                $1 = 1;
+            } else if (scm_is_pair($input)) {
+                // check the first element only
+                K* k;
+                SCM head = SCM_CAR($input);
+                if (scm_is_pair(head)) {
+                    SCM val = SCM_CDR(head);
+                    if (SWIG_ConvertPtr(val,(void **) &k,
+                                    $descriptor(K *), 0) != 0) {
+                        $1 = 0;
+                    } else {
+                        if (CHECK(val)) {
+                            $1 = 1;
+                        } else if (scm_is_pair(val)) {
+                            val = SCM_CAR(val);
+                            if (CHECK(val))
+                                $1 = 1;
+                            else
+                                $1 = 0;
+                        } else {
+                            $1 = 0;
+                        }
+                    }
+                } else {
+                    $1 = 0;
+                }
+            } else {
+                // wrapped map?
+                std::map< K, T >* m;
+                if (SWIG_ConvertPtr($input,(void **) &m,
+                                $&1_descriptor, 0) == 0)
+                    $1 = 1;
+                else
+                    $1 = 0;
+            }
+        }
+        %typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&,
+                                       const map<K,T>* {
+            // native sequence?
+            if (scm_is_null($input)) {
+                /* an empty sequence can be of any type */
+                $1 = 1;
+            } else if (scm_is_pair($input)) {
+                // check the first element only
+                K* k;
+                SCM head = SCM_CAR($input);
+                if (scm_is_pair(head)) {
+                    SCM val = SCM_CDR(head);
+                    if (SWIG_ConvertPtr(val,(void **) &k,
+                                    $descriptor(K *), 0) != 0) {
+                        $1 = 0;
+                    } else {
+                        if (CHECK(val)) {
+                            $1 = 1;
+                        } else if (scm_is_pair(val)) {
+                            val = SCM_CAR(val);
+                            if (CHECK(val))
+                                $1 = 1;
+                            else
+                                $1 = 0;
+                        } else {
+                            $1 = 0;
+                        }
+                    }
+                } else {
+                    $1 = 0;
+                }
+            } else {
+                // wrapped map?
+                std::map< K, T >* m;
+                if (SWIG_ConvertPtr($input,(void **) &m,
+                                $1_descriptor, 0) == 0)
+                    $1 = 1;
+                else
+                    $1 = 0;
+            }
+        }
+        %rename("length") size;
+        %rename("null?") empty;
+        %rename("clear!") clear;
+        %rename("ref") __getitem__;
+        %rename("set!") __setitem__;
+        %rename("delete!") __delitem__;
+        %rename("has-key?") has_key;
+      public:
+        map();
+        map(const map< K, T > &);
+        
+        unsigned int size() const;
+        bool empty() const;
+        void clear();
+        %extend {
+            T __getitem__(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 __setitem__(const K& key, T x) {
+                (*self)[key] = x;
+            }
+            void __delitem__(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();
+            }
+            SCM keys() {
+                SCM result = SCM_EOL;
+                for (std::map< K, T >::reverse_iterator i=self->rbegin(); i!=self->rend(); ++i) {
+                    K* key = new K(i->first);
+                    SCM k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
+                    result = scm_cons(k,result);
+                }
+                return result;
+            }
+        }
+    };
+    %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)
+    template<> class map<K,T> {
+        %typemap(in) map<K,T> {
+            if (scm_is_null($input)) {
+                $1 = std::map< K, T >();
+            } else if (scm_is_pair($input)) {
+                $1 = std::map< K, T >();
+                SCM alist = $input;
+                while (!scm_is_null(alist)) {
+                    SCM entry, key, val;
+                    entry = SCM_CAR(alist);
+                    if (!scm_is_pair(entry))
+                        SWIG_exception(SWIG_TypeError,"alist expected");
+                    key = SCM_CAR(entry);
+                    val = SCM_CDR(entry);
+                    if (!CHECK_K(key))
+                        SWIG_exception(SWIG_TypeError,
+                                           "map<" #K "," #T "> expected");
+                    if (!CHECK_T(val)) {
+                        if (!scm_is_pair(val))
+                            SWIG_exception(SWIG_TypeError,"alist expected");
+                        val = SCM_CAR(val);
+                        if (!CHECK_T(val))
+                            SWIG_exception(SWIG_TypeError,
+                                           "map<" #K "," #T "> expected");
+                    }
+                    (($1_type &)$1)[CONVERT_K_FROM(key)] = 
+                                               CONVERT_T_FROM(val);
+                    alist = SCM_CDR(alist);
+                }
+            } else {
+                $1 = *(($&1_type)
+                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
+            }
+        }
+        %typemap(in) const map<K,T>& (std::map<K,T> temp),
+                     const map<K,T>* (std::map<K,T> temp) {
+            if (scm_is_null($input)) {
+                temp = std::map< K, T >();
+                $1 = &temp;
+            } else if (scm_is_pair($input)) {
+                temp = std::map< K, T >();
+                $1 = &temp;
+                SCM alist = $input;
+                while (!scm_is_null(alist)) {
+                    SCM entry, key, val;
+                    entry = SCM_CAR(alist);
+                    if (!scm_is_pair(entry))
+                        SWIG_exception(SWIG_TypeError,"alist expected");
+                    key = SCM_CAR(entry);
+                    val = SCM_CDR(entry);
+                    if (!CHECK_K(key))
+                        SWIG_exception(SWIG_TypeError,
+                                           "map<" #K "," #T "> expected");
+                    if (!CHECK_T(val)) {
+                        if (!scm_is_pair(val))
+                            SWIG_exception(SWIG_TypeError,"alist expected");
+                        val = SCM_CAR(val);
+                        if (!CHECK_T(val))
+                            SWIG_exception(SWIG_TypeError,
+                                           "map<" #K "," #T "> expected");
+                    }
+                    temp[CONVERT_K_FROM(key)] = CONVERT_T_FROM(val);
+                    alist = SCM_CDR(alist);
+                }
+            } else {
+                $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
+            }
+        }
+        %typemap(out) map<K,T> {
+            SCM alist = SCM_EOL;
+            for (std::map< K, T >::reverse_iterator i=$1.rbegin(); i!=$1.rend(); ++i) {
+                SCM k = CONVERT_K_TO(i->first);
+                SCM x = CONVERT_T_TO(i->second);
+                SCM entry = scm_cons(k,x);
+                alist = scm_cons(entry,alist);
+            }
+            $result = alist;
+        }
+        %typecheck(SWIG_TYPECHECK_MAP) map<K,T> {
+            // native sequence?
+            if (scm_is_null($input)) {
+                /* an empty sequence can be of any type */
+                $1 = 1;
+            } else if (scm_is_pair($input)) {
+                // check the first element only
+                SCM head = SCM_CAR($input);
+                if (scm_is_pair(head)) {
+                    SCM key = SCM_CAR(head);
+                    SCM val = SCM_CDR(head);
+                    if (!CHECK_K(key)) {
+                        $1 = 0;
+                    } else {
+                        if (CHECK_T(val)) {
+                            $1 = 1;
+                        } else if (scm_is_pair(val)) {
+                            val = SCM_CAR(val);
+                            if (CHECK_T(val))
+                                $1 = 1;
+                            else
+                                $1 = 0;
+                        } else {
+                            $1 = 0;
+                        }
+                    }
+                } else {
+                    $1 = 0;
+                }
+            } else {
+                // wrapped map?
+                std::map< K, T >* m;
+                if (SWIG_ConvertPtr($input,(void **) &m,
+                                $&1_descriptor, 0) == 0)
+                    $1 = 1;
+                else
+                    $1 = 0;
+            }
+        }
+        %typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&,
+                                       const map<K,T>* {
+            // native sequence?
+            if (scm_is_null($input)) {
+                /* an empty sequence can be of any type */
+                $1 = 1;
+            } else if (scm_is_pair($input)) {
+                // check the first element only
+                SCM head = SCM_CAR($input);
+                if (scm_is_pair(head)) {
+                    SCM key = SCM_CAR(head);
+                    SCM val = SCM_CDR(head);
+                    if (!CHECK_K(key)) {
+                        $1 = 0;
+                    } else {
+                        if (CHECK_T(val)) {
+                            $1 = 1;
+                        } else if (scm_is_pair(val)) {
+                            val = SCM_CAR(val);
+                            if (CHECK_T(val))
+                                $1 = 1;
+                            else
+                                $1 = 0;
+                        } else {
+                            $1 = 0;
+                        }
+                    }
+                } else {
+                    $1 = 0;
+                }
+            } else {
+                // wrapped map?
+                std::map< K, T >* m;
+                if (SWIG_ConvertPtr($input,(void **) &m,
+                                $1_descriptor, 0) == 0)
+                    $1 = 1;
+                else
+                    $1 = 0;
+            }
+        }
+        %rename("length") size;
+        %rename("null?") empty;
+        %rename("clear!") clear;
+        %rename("ref") __getitem__;
+        %rename("set!") __setitem__;
+        %rename("delete!") __delitem__;
+        %rename("has-key?") has_key;
+      public:
+        map();
+        map(const map< K, T> &);
+        
+        unsigned int size() const;
+        bool empty() const;
+        void clear();
+        %extend {
+            T __getitem__(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 __setitem__(K key, T x) {
+                (*self)[key] = x;
+            }
+            void __delitem__(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(K key) {
+                std::map< K, T >::iterator i = self->find(key);
+                return i != self->end();
+            }
+            SCM keys() {
+                SCM result = SCM_EOL;
+                for (std::map< K, T >::reverse_iterator i=self->rbegin(); i!=self->rend(); ++i) {
+                    SCM k = CONVERT_K_TO(i->first);
+                    result = scm_cons(k,result);
+                }
+                return result;
+            }
+        }
+    };
+    %enddef
+
+
+    specialize_std_map_on_key(bool,scm_is_bool,
+                              scm_is_true,SWIG_bool2scm);
+    specialize_std_map_on_key(int,scm_is_number,
+                              scm_to_long,scm_from_long);
+    specialize_std_map_on_key(short,scm_is_number,
+                              scm_to_long,scm_from_long);
+    specialize_std_map_on_key(long,scm_is_number,
+                              scm_to_long,scm_from_long);
+    specialize_std_map_on_key(unsigned int,scm_is_number,
+                              scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_key(unsigned short,scm_is_number,
+                              scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_key(unsigned long,scm_is_number,
+                              scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_key(double,scm_is_number,
+                              scm_to_double,scm_from_double);
+    specialize_std_map_on_key(float,scm_is_number,
+                              scm_to_double,scm_from_double);
+    specialize_std_map_on_key(std::string,scm_is_string,
+                              SWIG_scm2string,SWIG_string2scm);
+
+    specialize_std_map_on_value(bool,scm_is_bool,
+                                scm_is_true,SWIG_bool2scm);
+    specialize_std_map_on_value(int,scm_is_number,
+                                scm_to_long,scm_from_long);
+    specialize_std_map_on_value(short,scm_is_number,
+                                scm_to_long,scm_from_long);
+    specialize_std_map_on_value(long,scm_is_number,
+                                scm_to_long,scm_from_long);
+    specialize_std_map_on_value(unsigned int,scm_is_number,
+                                scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_value(unsigned short,scm_is_number,
+                                scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_value(unsigned long,scm_is_number,
+                                scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_value(double,scm_is_number,
+                                scm_to_double,scm_from_double);
+    specialize_std_map_on_value(float,scm_is_number,
+                                scm_to_double,scm_from_double);
+    specialize_std_map_on_value(std::string,scm_is_string,
+                                SWIG_scm2string,SWIG_string2scm);
+
+    specialize_std_map_on_both(bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm,
+                               bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm);
+    specialize_std_map_on_both(bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm,
+                               int,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm,
+                               short,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm,
+                               long,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm,
+                               unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm,
+                               unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm,
+                               unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm,
+                               double,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_map_on_both(bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm,
+                               float,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_map_on_both(bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm,
+                               std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm);
+    specialize_std_map_on_both(int,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm);
+    specialize_std_map_on_both(int,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               int,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(int,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               short,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(int,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               long,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(int,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(int,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(int,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(int,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               double,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_map_on_both(int,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               float,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_map_on_both(int,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm);
+    specialize_std_map_on_both(short,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm);
+    specialize_std_map_on_both(short,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               int,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(short,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               short,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(short,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               long,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(short,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(short,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(short,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(short,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               double,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_map_on_both(short,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               float,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_map_on_both(short,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm);
+    specialize_std_map_on_both(long,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm);
+    specialize_std_map_on_both(long,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               int,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(long,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               short,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(long,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               long,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(long,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(long,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(long,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(long,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               double,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_map_on_both(long,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               float,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_map_on_both(long,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm);
+    specialize_std_map_on_both(unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm);
+    specialize_std_map_on_both(unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               int,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               short,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               long,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               double,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_map_on_both(unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               float,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_map_on_both(unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm);
+    specialize_std_map_on_both(unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm);
+    specialize_std_map_on_both(unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               int,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               short,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               long,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               double,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_map_on_both(unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               float,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_map_on_both(unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm);
+    specialize_std_map_on_both(unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm);
+    specialize_std_map_on_both(unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               int,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               short,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               long,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               double,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_map_on_both(unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               float,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_map_on_both(unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm);
+    specialize_std_map_on_both(double,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm);
+    specialize_std_map_on_both(double,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               int,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(double,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               short,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(double,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               long,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(double,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(double,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(double,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(double,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               double,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_map_on_both(double,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               float,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_map_on_both(double,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm);
+    specialize_std_map_on_both(float,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm);
+    specialize_std_map_on_both(float,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               int,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(float,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               short,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(float,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               long,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(float,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(float,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(float,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(float,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               double,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_map_on_both(float,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               float,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_map_on_both(float,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm);
+    specialize_std_map_on_both(std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm,
+                               bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm);
+    specialize_std_map_on_both(std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm,
+                               int,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm,
+                               short,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm,
+                               long,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_map_on_both(std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm,
+                               unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm,
+                               unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm,
+                               unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_map_on_both(std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm,
+                               double,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_map_on_both(std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm,
+                               float,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_map_on_both(std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm,
+                               std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm);
+}
diff --git a/share/swig/3.0.12/guile/std_pair.i b/share/swig/3.0.12/guile/std_pair.i
new file mode 100644
index 0000000..92dec5f
--- /dev/null
+++ b/share/swig/3.0.12/guile/std_pair.i
@@ -0,0 +1,863 @@
+/* -----------------------------------------------------------------------------
+ * std_pair.i
+ *
+ * SWIG typemaps for std::pair
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+%include <exception.i>
+
+// ------------------------------------------------------------------------
+// std::pair
+//
+// See std_vector.i for the rationale of typemap application
+// ------------------------------------------------------------------------
+
+%{
+#include <utility>
+%}
+
+// exported class
+
+namespace std {
+
+    template<class T, class U> struct pair {
+        %typemap(in) pair<T,U> %{
+            if (scm_is_pair($input)) {
+                T* x;
+                U* y;
+                SCM first, second;
+                first = SCM_CAR($input);
+                second = SCM_CDR($input);
+                x = (T*) SWIG_MustGetPtr(first,$descriptor(T *),$argnum, 0);
+                y = (U*) SWIG_MustGetPtr(second,$descriptor(U *),$argnum, 0);
+                $1 = std::make_pair(*x,*y);
+            } else {
+                $1 = *(($&1_type)
+                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
+            }
+        %}
+        %typemap(in) const pair<T,U>& (std::pair<T,U> *temp = 0),
+                     const pair<T,U>* (std::pair<T,U> *temp = 0) %{
+            if (scm_is_pair($input)) {
+                T* x;
+                U* y;
+                SCM first, second;
+                first = SCM_CAR($input);
+                second = SCM_CDR($input);
+                x = (T*) SWIG_MustGetPtr(first,$descriptor(T *),$argnum, 0);
+                y = (U*) SWIG_MustGetPtr(second,$descriptor(U *),$argnum, 0);
+                temp = new std::pair< T, U >(*x,*y);
+                $1 = temp;
+            } else {
+                $1 = ($1_ltype)
+                    SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
+            }
+        %}
+        %typemap(freearg) const pair<T,U>&, const pair<T,U>* %{ delete temp$argnum; %}
+        %typemap(out) pair<T,U> {
+            T* x = new T($1.first);
+            U* y = new U($1.second);
+            SCM first = SWIG_NewPointerObj(x,$descriptor(T *), 1);
+            SCM second = SWIG_NewPointerObj(y,$descriptor(U *), 1);
+            $result = scm_cons(first,second);
+        }
+        %typecheck(SWIG_TYPECHECK_PAIR) pair<T,U> {
+            /* native pair? */
+            if (scm_is_pair($input)) {
+                T* x;
+                U* y;
+                SCM first = SCM_CAR($input);
+                SCM second = SCM_CDR($input);
+                if (SWIG_ConvertPtr(first,(void**) &x,
+                                    $descriptor(T *), 0) == 0 &&
+                    SWIG_ConvertPtr(second,(void**) &y,
+                                    $descriptor(U *), 0) == 0) {
+                    $1 = 1;
+                } else {
+                    $1 = 0;
+                }
+            } else {
+                /* wrapped pair? */
+                std::pair< T, U >* m;
+                if (SWIG_ConvertPtr($input,(void **) &m,
+                                    $&1_descriptor, 0) == 0)
+                    $1 = 1;
+                else
+                    $1 = 0;
+            }
+        }
+        %typecheck(SWIG_TYPECHECK_PAIR) const pair<T,U>&,
+                                        const pair<T,U>* {
+            /* native pair? */
+            if (scm_is_pair($input)) {
+                T* x;
+                U* y;
+                SCM first = SCM_CAR($input);
+                SCM second = SCM_CDR($input);
+                if (SWIG_ConvertPtr(first,(void**) &x,
+                                    $descriptor(T *), 0) == 0 &&
+                    SWIG_ConvertPtr(second,(void**) &y,
+                                    $descriptor(U *), 0) == 0) {
+                    $1 = 1;
+                } else {
+                    $1 = 0;
+                }
+            } else {
+                /* wrapped pair? */
+                std::pair< T, U >* m;
+                if (SWIG_ConvertPtr($input,(void **) &m,
+                                    $1_descriptor, 0) == 0)
+                    $1 = 1;
+                else
+                    $1 = 0;
+            }
+        }
+        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;
+    };
+
+
+    // specializations for built-ins
+
+    %define specialize_std_pair_on_first(T,CHECK,CONVERT_FROM,CONVERT_TO)
+    template<class U> struct pair<T,U> {
+        %typemap(in) pair<T,U> %{
+            if (scm_is_pair($input)) {
+                U* y;
+                SCM first, second;
+                first = SCM_CAR($input);
+                second = SCM_CDR($input);
+                if (!CHECK(first))
+                    SWIG_exception(SWIG_TypeError,
+                                   "pair<" #T "," #U "> expected");
+                y = (U*) SWIG_MustGetPtr(second,$descriptor(U *),$argnum, 0);
+                $1 = std::make_pair(CONVERT_FROM(first),*y);
+            } else {
+                $1 = *(($&1_type)
+                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
+            }
+        %}
+        %typemap(in) const pair<T,U>& (std::pair<T,U> *temp = 0),
+                     const pair<T,U>* (std::pair<T,U> *temp = 0) %{
+            if (scm_is_pair($input)) {
+                U* y;
+                SCM first, second;
+                first = SCM_CAR($input);
+                second = SCM_CDR($input);
+                if (!CHECK(first))
+                    SWIG_exception(SWIG_TypeError,
+                                   "pair<" #T "," #U "> expected");
+                y = (U*) SWIG_MustGetPtr(second,$descriptor(U *),$argnum, 0);
+                temp = new std::pair< T, U >(CONVERT_FROM(first),*y);
+                $1 = temp;
+            } else {
+                $1 = ($1_ltype)
+                    SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
+            }
+        %}
+        %typemap(freearg) const pair<T,U>&, const pair<T,U>* %{ delete temp$argnum; %}
+        %typemap(out) pair<T,U> {
+            U* y = new U($1.second);
+            SCM second = SWIG_NewPointerObj(y,$descriptor(U *), 1);
+            $result = scm_cons(CONVERT_TO($1.first),second);
+        }
+        %typecheck(SWIG_TYPECHECK_PAIR) pair<T,U> {
+            /* native pair? */
+            if (scm_is_pair($input)) {
+                U* y;
+                SCM first = SCM_CAR($input);
+                SCM second = SCM_CDR($input);
+                if (CHECK(first) &&
+                    SWIG_ConvertPtr(second,(void**) &y,
+                                    $descriptor(U *), 0) == 0) {
+                    $1 = 1;
+                } else {
+                    $1 = 0;
+                }
+            } else {
+                /* wrapped pair? */
+                std::pair< T, U >* m;
+                if (SWIG_ConvertPtr($input,(void **) &m,
+                                    $&1_descriptor, 0) == 0)
+                    $1 = 1;
+                else
+                    $1 = 0;
+            }
+        }
+        %typecheck(SWIG_TYPECHECK_PAIR) const pair<T,U>&,
+                                        const pair<T,U>* {
+            /* native pair? */
+            if (scm_is_pair($input)) {
+                U* y;
+                SCM first = SCM_CAR($input);
+                SCM second = SCM_CDR($input);
+                if (CHECK(first) &&
+                    SWIG_ConvertPtr(second,(void**) &y,
+                                    $descriptor(U *), 0) == 0) {
+                    $1 = 1;
+                } else {
+                    $1 = 0;
+                }
+            } else {
+                /* wrapped pair? */
+                std::pair< T, U >* m;
+                if (SWIG_ConvertPtr($input,(void **) &m,
+                                    $1_descriptor, 0) == 0)
+                    $1 = 1;
+                else
+                    $1 = 0;
+            }
+        }
+        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;
+    };
+    %enddef
+
+    %define specialize_std_pair_on_second(U,CHECK,CONVERT_FROM,CONVERT_TO)
+    template<class T> struct pair<T,U> {
+        %typemap(in) pair<T,U> %{
+            if (scm_is_pair($input)) {
+                T* x;
+                SCM first, second;
+                first = SCM_CAR($input);
+                second = SCM_CDR($input);
+                x = (T*) SWIG_MustGetPtr(first,$descriptor(T *),$argnum, 0);
+                if (!CHECK(second))
+                    SWIG_exception(SWIG_TypeError,
+                                   "pair<" #T "," #U "> expected");
+                $1 = std::make_pair(*x,CONVERT_FROM(second));
+            } else {
+                $1 = *(($&1_type)
+                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
+            }
+        %}
+        %typemap(in) const pair<T,U>& (std::pair<T,U> *temp = 0),
+                     const pair<T,U>* (std::pair<T,U> *temp = 0) %{
+            if (scm_is_pair($input)) {
+                T* x;
+                SCM first, second;
+                first = SCM_CAR($input);
+                second = SCM_CDR($input);
+                x = (T*) SWIG_MustGetPtr(first,$descriptor(T *),$argnum, 0);
+                if (!CHECK(second))
+                    SWIG_exception(SWIG_TypeError,
+                                   "pair<" #T "," #U "> expected");
+                temp = new std::pair< T, U >(*x,CONVERT_FROM(second));
+                $1 = temp;
+            } else {
+                $1 = ($1_ltype)
+                    SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
+            }
+        %}
+        %typemap(freearg) const pair<T,U>&, const pair<T,U>* %{ delete temp$argnum; %}
+        %typemap(out) pair<T,U> {
+            T* x = new T($1.first);
+            SCM first = SWIG_NewPointerObj(x,$descriptor(T *), 1);
+            $result = scm_cons(first,CONVERT_TO($1.second));
+        }
+        %typecheck(SWIG_TYPECHECK_PAIR) pair<T,U> {
+            /* native pair? */
+            if (scm_is_pair($input)) {
+                T* x;
+                SCM first = SCM_CAR($input);
+                SCM second = SCM_CDR($input);
+                if (SWIG_ConvertPtr(first,(void**) &x,
+                                    $descriptor(T *), 0) == 0 &&
+                    CHECK(second)) {
+                    $1 = 1;
+                } else {
+                    $1 = 0;
+                }
+            } else {
+                /* wrapped pair? */
+                std::pair< T, U >* m;
+                if (SWIG_ConvertPtr($input,(void **) &m,
+                                    $&1_descriptor, 0) == 0)
+                    $1 = 1;
+                else
+                    $1 = 0;
+            }
+        }
+        %typecheck(SWIG_TYPECHECK_PAIR) const pair<T,U>&,
+                                        const pair<T,U>* {
+            /* native pair? */
+            if (scm_is_pair($input)) {
+                T* x;
+                SCM first = SCM_CAR($input);
+                SCM second = SCM_CDR($input);
+                if (SWIG_ConvertPtr(first,(void**) &x,
+                                    $descriptor(T *), 0) == 0 &&
+                    CHECK(second)) {
+                    $1 = 1;
+                } else {
+                    $1 = 0;
+                }
+            } else {
+                /* wrapped pair? */
+                std::pair< T, U >* m;
+                if (SWIG_ConvertPtr($input,(void **) &m,
+                                    $1_descriptor, 0) == 0)
+                    $1 = 1;
+                else
+                    $1 = 0;
+            }
+        }
+        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;
+    };
+    %enddef
+
+    %define specialize_std_pair_on_both(T,CHECK_T,CONVERT_T_FROM,CONVERT_T_TO,
+                                        U,CHECK_U,CONVERT_U_FROM,CONVERT_U_TO)
+    template<> struct pair<T,U> {
+        %typemap(in) pair<T,U> %{
+            if (scm_is_pair($input)) {
+                SCM first, second;
+                first = SCM_CAR($input);
+                second = SCM_CDR($input);
+                if (!CHECK_T(first) || !CHECK_U(second))
+                    SWIG_exception(SWIG_TypeError,
+                                   "pair<" #T "," #U "> expected");
+                $1 = std::make_pair(CONVERT_T_FROM(first),
+                                    CONVERT_U_FROM(second));
+            } else {
+                $1 = *(($&1_type)
+                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
+            }
+        %}
+        %typemap(in) const pair<T,U>& (std::pair<T,U> *temp = 0),
+                     const pair<T,U>* (std::pair<T,U> *temp = 0) %{
+            if (scm_is_pair($input)) {
+                SCM first, second;
+                first = SCM_CAR($input);
+                second = SCM_CDR($input);
+                if (!CHECK_T(first) || !CHECK_U(second))
+                    SWIG_exception(SWIG_TypeError,
+                                   "pair<" #T "," #U "> expected");
+                temp = new std::pair< T, U >(CONVERT_T_FROM(first), CONVERT_U_FROM(second));
+                $1 = temp;
+            } else {
+                $1 = ($1_ltype)
+                    SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
+            }
+        %}
+        %typemap(freearg) const pair<T,U>&, const pair<T,U>* %{ delete temp$argnum; %}
+        %typemap(out) pair<T,U> {
+            $result = scm_cons(CONVERT_T_TO($1.first),
+                              CONVERT_U_TO($1.second));
+        }
+        %typecheck(SWIG_TYPECHECK_PAIR) pair<T,U> {
+            /* native pair? */
+            if (scm_is_pair($input)) {
+                SCM first = SCM_CAR($input);
+                SCM second = SCM_CDR($input);
+                if (CHECK_T(first) && CHECK_U(second)) {
+                    $1 = 1;
+                } else {
+                    $1 = 0;
+                }
+            } else {
+                /* wrapped pair? */
+                std::pair< T, U >* m;
+                if (SWIG_ConvertPtr($input,(void **) &m,
+                                    $&1_descriptor, 0) == 0)
+                    $1 = 1;
+                else
+                    $1 = 0;
+            }
+        }
+        %typecheck(SWIG_TYPECHECK_PAIR) const pair<T,U>&,
+                                        const pair<T,U>* {
+            /* native pair? */
+            if (scm_is_pair($input)) {
+                SCM first = SCM_CAR($input);
+                SCM second = SCM_CDR($input);
+                if (CHECK_T(first) && CHECK_U(second)) {
+                    $1 = 1;
+                } else {
+                    $1 = 0;
+                }
+            } else {
+                /* wrapped pair? */
+                std::pair< T, U >* m;
+                if (SWIG_ConvertPtr($input,(void **) &m,
+                                    $1_descriptor, 0) == 0)
+                    $1 = 1;
+                else
+                    $1 = 0;
+            }
+        }
+        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;
+    };
+    %enddef
+
+
+    specialize_std_pair_on_first(bool,scm_is_bool,
+                              scm_is_true,SWIG_bool2scm);
+    specialize_std_pair_on_first(int,scm_is_number,
+                              scm_to_long,scm_from_long);
+    specialize_std_pair_on_first(short,scm_is_number,
+                              scm_to_long,scm_from_long);
+    specialize_std_pair_on_first(long,scm_is_number,
+                              scm_to_long,scm_from_long);
+    specialize_std_pair_on_first(unsigned int,scm_is_number,
+                              scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_first(unsigned short,scm_is_number,
+                              scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_first(unsigned long,scm_is_number,
+                              scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_first(double,scm_is_number,
+                              scm_to_double,scm_from_double);
+    specialize_std_pair_on_first(float,scm_is_number,
+                              scm_to_double,scm_from_double);
+    specialize_std_pair_on_first(std::string,scm_is_string,
+                              SWIG_scm2string,SWIG_string2scm);
+
+    specialize_std_pair_on_second(bool,scm_is_bool,
+                                scm_is_true,SWIG_bool2scm);
+    specialize_std_pair_on_second(int,scm_is_number,
+                                scm_to_long,scm_from_long);
+    specialize_std_pair_on_second(short,scm_is_number,
+                                scm_to_long,scm_from_long);
+    specialize_std_pair_on_second(long,scm_is_number,
+                                scm_to_long,scm_from_long);
+    specialize_std_pair_on_second(unsigned int,scm_is_number,
+                                scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_second(unsigned short,scm_is_number,
+                                scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_second(unsigned long,scm_is_number,
+                                scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_second(double,scm_is_number,
+                                scm_to_double,scm_from_double);
+    specialize_std_pair_on_second(float,scm_is_number,
+                                scm_to_double,scm_from_double);
+    specialize_std_pair_on_second(std::string,scm_is_string,
+                                SWIG_scm2string,SWIG_string2scm);
+
+    specialize_std_pair_on_both(bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm,
+                               bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm);
+    specialize_std_pair_on_both(bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm,
+                               int,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm,
+                               short,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm,
+                               long,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm,
+                               unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm,
+                               unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm,
+                               unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm,
+                               double,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_pair_on_both(bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm,
+                               float,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_pair_on_both(bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm,
+                               std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm);
+    specialize_std_pair_on_both(int,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm);
+    specialize_std_pair_on_both(int,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               int,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(int,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               short,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(int,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               long,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(int,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(int,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(int,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(int,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               double,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_pair_on_both(int,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               float,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_pair_on_both(int,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm);
+    specialize_std_pair_on_both(short,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm);
+    specialize_std_pair_on_both(short,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               int,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(short,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               short,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(short,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               long,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(short,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(short,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(short,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(short,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               double,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_pair_on_both(short,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               float,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_pair_on_both(short,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm);
+    specialize_std_pair_on_both(long,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm);
+    specialize_std_pair_on_both(long,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               int,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(long,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               short,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(long,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               long,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(long,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(long,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(long,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(long,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               double,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_pair_on_both(long,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               float,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_pair_on_both(long,scm_is_number,
+                               scm_to_long,scm_from_long,
+                               std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm);
+    specialize_std_pair_on_both(unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm);
+    specialize_std_pair_on_both(unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               int,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               short,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               long,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               double,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_pair_on_both(unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               float,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_pair_on_both(unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm);
+    specialize_std_pair_on_both(unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm);
+    specialize_std_pair_on_both(unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               int,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               short,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               long,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               double,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_pair_on_both(unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               float,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_pair_on_both(unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm);
+    specialize_std_pair_on_both(unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm);
+    specialize_std_pair_on_both(unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               int,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               short,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               long,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               double,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_pair_on_both(unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               float,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_pair_on_both(unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong,
+                               std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm);
+    specialize_std_pair_on_both(double,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm);
+    specialize_std_pair_on_both(double,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               int,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(double,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               short,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(double,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               long,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(double,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(double,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(double,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(double,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               double,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_pair_on_both(double,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               float,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_pair_on_both(double,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm);
+    specialize_std_pair_on_both(float,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm);
+    specialize_std_pair_on_both(float,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               int,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(float,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               short,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(float,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               long,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(float,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(float,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(float,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(float,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               double,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_pair_on_both(float,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               float,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_pair_on_both(float,scm_is_number,
+                               scm_to_double,scm_from_double,
+                               std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm);
+    specialize_std_pair_on_both(std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm,
+                               bool,scm_is_bool,
+                               scm_is_true,SWIG_bool2scm);
+    specialize_std_pair_on_both(std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm,
+                               int,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm,
+                               short,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm,
+                               long,scm_is_number,
+                               scm_to_long,scm_from_long);
+    specialize_std_pair_on_both(std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm,
+                               unsigned int,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm,
+                               unsigned short,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm,
+                               unsigned long,scm_is_number,
+                               scm_to_ulong,scm_from_ulong);
+    specialize_std_pair_on_both(std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm,
+                               double,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_pair_on_both(std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm,
+                               float,scm_is_number,
+                               scm_to_double,scm_from_double);
+    specialize_std_pair_on_both(std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm,
+                               std::string,scm_is_string,
+                               SWIG_scm2string,SWIG_string2scm);
+}
diff --git a/share/swig/2.0.11/guile/std_string.i b/share/swig/3.0.12/guile/std_string.i
index 6513173..6513173 100644
--- a/share/swig/2.0.11/guile/std_string.i
+++ b/share/swig/3.0.12/guile/std_string.i
diff --git a/share/swig/3.0.12/guile/std_vector.i b/share/swig/3.0.12/guile/std_vector.i
new file mode 100644
index 0000000..d7a7140
--- /dev/null
+++ b/share/swig/3.0.12/guile/std_vector.i
@@ -0,0 +1,406 @@
+/* -----------------------------------------------------------------------------
+ * std_vector.i
+ *
+ * SWIG typemaps for std::vector
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+
+// ------------------------------------------------------------------------
+// std::vector
+// 
+// The aim of all that follows would be to integrate std::vector with 
+// Guile as much as possible, namely, to allow the user to pass and 
+// be returned Guile vectors or lists.
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+// 
+//   -- f(std::vector<T>), f(const std::vector<T>&), f(const std::vector<T>*):
+//      the parameter being read-only, either a Guile sequence or a
+//      previously wrapped std::vector<T> can be passed.
+//   -- f(std::vector<T>&), f(std::vector<T>*):
+//      the parameter must be modified; therefore, only a wrapped std::vector
+//      can be passed.
+//   -- std::vector<T> f():
+//      the vector is returned by copy; therefore, a Guile vector of T:s 
+//      is returned which is most easily used in other Guile functions
+//   -- std::vector<T>& f(), std::vector<T>* f(), const std::vector<T>& f(),
+//      const std::vector<T>* f():
+//      the vector is returned by reference; therefore, a wrapped std::vector
+//      is returned
+// ------------------------------------------------------------------------
+
+%{
+#include <vector>
+#include <algorithm>
+#include <stdexcept>
+%}
+
+// exported class
+
+namespace std {
+    
+    template<class T> class vector {
+        %typemap(in) vector<T> {
+            if (scm_is_vector($input)) {
+                unsigned long size = scm_c_vector_length($input);
+                $1 = std::vector< T >(size);
+                for (unsigned long i=0; i<size; i++) {
+                    SCM o = scm_vector_ref($input,scm_from_ulong(i));
+                    (($1_type &)$1)[i] =
+                        *((T*) SWIG_MustGetPtr(o,$descriptor(T *),$argnum, 0));
+                }
+            } else if (scm_is_null($input)) {
+                $1 = std::vector< T >();
+            } else if (scm_is_pair($input)) {
+                SCM head, tail;
+                $1 = std::vector< T >();
+                tail = $input;
+                while (!scm_is_null(tail)) {
+                    head = SCM_CAR(tail);
+                    tail = SCM_CDR(tail);
+                    $1.push_back(*((T*)SWIG_MustGetPtr(head,
+                                                       $descriptor(T *),
+                                                       $argnum, 0)));
+                }
+            } else {
+                $1 = *(($&1_type)
+                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
+            }
+        }
+        %typemap(in) const vector<T>& (std::vector<T> temp),
+                     const vector<T>* (std::vector<T> temp) {
+            if (scm_is_vector($input)) {
+                unsigned long size = scm_c_vector_length($input);
+                temp = std::vector< T >(size);
+                $1 = &temp;
+                for (unsigned long i=0; i<size; i++) {
+                    SCM o = scm_vector_ref($input,scm_from_ulong(i));
+                    temp[i] = *((T*) SWIG_MustGetPtr(o,
+                                                     $descriptor(T *),
+                                                     $argnum, 0));
+                }
+            } else if (scm_is_null($input)) {
+                temp = std::vector< T >();
+                $1 = &temp;
+            } else if (scm_is_pair($input)) {
+                temp = std::vector< T >();
+                $1 = &temp;
+                SCM head, tail;
+                tail = $input;
+                while (!scm_is_null(tail)) {
+                    head = SCM_CAR(tail);
+                    tail = SCM_CDR(tail);
+                    temp.push_back(*((T*) SWIG_MustGetPtr(head,
+                                                          $descriptor(T *),
+                                                          $argnum, 0)));
+                }
+            } else {
+                $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
+            }
+        }
+        %typemap(out) vector<T> {
+            $result = scm_make_vector(scm_from_long($1.size()),SCM_UNSPECIFIED);
+            for (unsigned int i=0; i<$1.size(); i++) {
+                T* x = new T((($1_type &)$1)[i]);
+                scm_vector_set_x($result,scm_from_long(i),
+                                SWIG_NewPointerObj(x, $descriptor(T *), 1));
+            }
+        }
+        %typecheck(SWIG_TYPECHECK_VECTOR) vector<T> {
+            /* native sequence? */
+            if (scm_is_vector($input)) {
+                unsigned int size = scm_c_vector_length($input);
+                if (size == 0) {
+                    /* an empty sequence can be of any type */
+                    $1 = 1;
+                } else {
+                    /* check the first element only */
+                    SCM o = scm_vector_ref($input,scm_from_ulong(0));
+                    T* x;
+                    if (SWIG_ConvertPtr(o,(void**) &x,
+                                          $descriptor(T *), 0) != -1)
+                        $1 = 1;
+                    else
+                        $1 = 0;
+                }
+            } else if (scm_is_null($input)) {
+                /* again, an empty sequence can be of any type */
+                $1 = 1;
+            } else if (scm_is_pair($input)) {
+                /* check the first element only */
+                T* x;
+                SCM head = SCM_CAR($input);
+                if (SWIG_ConvertPtr(head,(void**) &x,
+                                      $descriptor(T *), 0) != -1)
+                    $1 = 1;
+                else
+                    $1 = 0;
+            } else {
+                /* wrapped vector? */
+                std::vector< T >* v;
+                if (SWIG_ConvertPtr($input,(void **) &v, 
+                                      $&1_descriptor, 0) != -1)
+                    $1 = 1;
+                else
+                    $1 = 0;
+            }
+        }
+        %typecheck(SWIG_TYPECHECK_VECTOR) const vector<T>&,
+                                          const vector<T>* {
+            /* native sequence? */
+            if (scm_is_vector($input)) {
+                unsigned int size = scm_c_vector_length($input);
+                if (size == 0) {
+                    /* an empty sequence can be of any type */
+                    $1 = 1;
+                } else {
+                    /* check the first element only */
+                    T* x;
+                    SCM o = scm_vector_ref($input,scm_from_ulong(0));
+                    if (SWIG_ConvertPtr(o,(void**) &x,
+                                          $descriptor(T *), 0) != -1)
+                        $1 = 1;
+                    else
+                        $1 = 0;
+                }
+            } else if (scm_is_null($input)) {
+                /* again, an empty sequence can be of any type */
+                $1 = 1;
+            } else if (scm_is_pair($input)) {
+                /* check the first element only */
+                T* x;
+                SCM head = SCM_CAR($input);
+                if (SWIG_ConvertPtr(head,(void**) &x,
+                                      $descriptor(T *), 0) != -1)
+                    $1 = 1;
+                else
+                    $1 = 0;
+            } else {
+                /* wrapped vector? */
+                std::vector< T >* v;
+                if (SWIG_ConvertPtr($input,(void **) &v, 
+                                      $1_descriptor, 0) != -1)
+                    $1 = 1;
+                else
+                    $1 = 0;
+            }
+        }
+      public:
+        vector(unsigned int size = 0);
+        vector(unsigned int size, const T& value);
+        vector(const vector<T>&);
+        %rename(length) size;
+        unsigned int size() const;
+        %rename("empty?") empty;
+        bool empty() const;
+        %rename("clear!") clear;
+        void clear();
+        %rename("set!") set;
+        %rename("pop!") pop;
+        %rename("push!") push_back;
+        void push_back(const T& x);
+        %extend {
+            T pop() throw (std::out_of_range) {
+                if (self->size() == 0)
+                    throw std::out_of_range("pop from empty vector");
+                T x = self->back();
+                self->pop_back();
+                return x;
+            }
+            const T& ref(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 T& x) throw (std::out_of_range) {
+                int size = int(self->size());
+                if (i>=0 && i<size)
+                    (*self)[i] = x;
+                else
+                    throw std::out_of_range("vector index out of range");
+            }
+        }
+    };
+
+
+    // specializations for built-ins
+    %define specialize_stl_vector(T,CHECK,CONVERT_FROM,CONVERT_TO)
+    template<> class vector<T> {
+        %typemap(in) vector<T> {
+            if (scm_is_vector($input)) {
+                unsigned long size = scm_c_vector_length($input);
+                $1 = std::vector< T >(size);
+                for (unsigned long i=0; i<size; i++) {
+                    SCM o = scm_vector_ref($input,scm_from_ulong(i));
+                    if (CHECK(o))
+                        (($1_type &)$1)[i] = (T)(CONVERT_FROM(o));
+                    else
+                        scm_wrong_type_arg(FUNC_NAME, $argnum, $input);
+                }
+            } else if (scm_is_null($input)) {
+                $1 = std::vector<T >();
+            } else if (scm_is_pair($input)) {
+                SCM v = scm_vector($input);
+                unsigned long size = scm_c_vector_length(v);
+                $1 = std::vector< T >(size);
+                for (unsigned long i=0; i<size; i++) {
+                    SCM o = scm_vector_ref(v,scm_from_ulong(i));
+                    if (CHECK(o))
+                        (($1_type &)$1)[i] = (T)(CONVERT_FROM(o));
+                    else
+                        scm_wrong_type_arg(FUNC_NAME, $argnum, $input);
+                }
+            } else {
+                $1 = *(($&1_type)
+                       SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
+            }
+        }
+        %typemap(in) const vector<T>& (std::vector<T> temp),
+                     const vector<T>* (std::vector<T> temp) {
+            if (scm_is_vector($input)) {
+                unsigned long size = scm_c_vector_length($input);
+                temp = std::vector< T >(size);
+                $1 = &temp;
+                for (unsigned long i=0; i<size; i++) {
+                    SCM o = scm_vector_ref($input,scm_from_ulong(i));
+                    if (CHECK(o))
+                        temp[i] = (T)(CONVERT_FROM(o));
+                    else
+                        scm_wrong_type_arg(FUNC_NAME, $argnum, $input);
+                }
+            } else if (scm_is_null($input)) {
+                temp = std::vector< T >();
+                $1 = &temp;
+            } else if (scm_is_pair($input)) {
+                SCM v = scm_vector($input);
+                unsigned long size = scm_c_vector_length(v);
+                temp = std::vector< T >(size);
+                $1 = &temp;
+                for (unsigned long i=0; i<size; i++) {
+                    SCM o = scm_vector_ref(v,scm_from_ulong(i));
+                    if (CHECK(o))
+                        temp[i] = (T)(CONVERT_FROM(o));
+                    else
+                        scm_wrong_type_arg(FUNC_NAME, $argnum, $input);
+                }
+            } else {
+                $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
+            }
+        }
+        %typemap(out) vector<T> {
+            $result = scm_make_vector(scm_from_long($1.size()),SCM_UNSPECIFIED);
+            for (unsigned int i=0; i<$1.size(); i++) {
+                SCM x = CONVERT_TO((($1_type &)$1)[i]);
+                scm_vector_set_x($result,scm_from_long(i),x);
+            }
+        }
+        %typecheck(SWIG_TYPECHECK_VECTOR) vector<T> {
+            /* native sequence? */
+            if (scm_is_vector($input)) {
+                unsigned int size = scm_c_vector_length($input);
+                if (size == 0) {
+                    /* an empty sequence can be of any type */
+                    $1 = 1;
+                } else {
+                    /* check the first element only */
+                    SCM o = scm_vector_ref($input,scm_from_ulong(0));
+                    $1 = CHECK(o) ? 1 : 0;
+                }
+            } else if (scm_is_null($input)) {
+                /* again, an empty sequence can be of any type */
+                $1 = 1;
+            } else if (scm_is_pair($input)) {
+                /* check the first element only */
+                SCM head = SCM_CAR($input);
+                $1 = CHECK(head) ? 1 : 0;
+            } else {
+                /* wrapped vector? */
+                std::vector< T >* v;
+                $1 = (SWIG_ConvertPtr($input,(void **) &v, 
+                                        $&1_descriptor, 0) != -1) ? 1 : 0;
+            }
+        }
+        %typecheck(SWIG_TYPECHECK_VECTOR) const vector<T>&,
+                                          const vector<T>* {
+            /* native sequence? */
+            if (scm_is_vector($input)) {
+                unsigned int size = scm_c_vector_length($input);
+                if (size == 0) {
+                    /* an empty sequence can be of any type */
+                    $1 = 1;
+                } else {
+                    /* check the first element only */
+                    SCM o = scm_vector_ref($input,scm_from_ulong(0));
+                    $1 = CHECK(o) ? 1 : 0;
+                }
+            } else if (scm_is_null($input)) {
+                /* again, an empty sequence can be of any type */
+                $1 = 1;
+            } else if (scm_is_pair($input)) {
+                /* check the first element only */
+                SCM head = SCM_CAR($input);
+                $1 = CHECK(head) ? 1 : 0;
+            } else {
+                /* wrapped vector? */
+                std::vector< T >* v;
+                $1 = (SWIG_ConvertPtr($input,(void **) &v, 
+                                        $1_descriptor, 0) != -1) ? 1 : 0;
+            }
+        }
+      public:
+        vector(unsigned int size = 0);
+        vector(unsigned int size, const T& value);
+        vector(const vector<T>&);
+        %rename(length) size;
+        unsigned int size() const;
+        %rename("empty?") empty;
+        bool empty() const;
+        %rename("clear!") clear;
+        void clear();
+        %rename("set!") set;
+        %rename("pop!") pop;
+        %rename("push!") push_back;
+        void push_back(T x);
+        %extend {
+            T pop() throw (std::out_of_range) {
+                if (self->size() == 0)
+                    throw std::out_of_range("pop from empty vector");
+                T x = self->back();
+                self->pop_back();
+                return x;
+            }
+            T ref(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, T x) throw (std::out_of_range) {
+                int size = int(self->size());
+                if (i>=0 && i<size)
+                    (*self)[i] = x;
+                else
+                    throw std::out_of_range("vector index out of range");
+            }
+        }
+    };
+    %enddef
+
+    specialize_stl_vector(bool,scm_is_bool,scm_is_true,SWIG_bool2scm);
+    specialize_stl_vector(char,scm_is_number,scm_to_long,scm_from_long);
+    specialize_stl_vector(int,scm_is_number,scm_to_long,scm_from_long);
+    specialize_stl_vector(long,scm_is_number,scm_to_long,scm_from_long);
+    specialize_stl_vector(short,scm_is_number,scm_to_long,scm_from_long);
+    specialize_stl_vector(unsigned char,scm_is_number,scm_to_ulong,scm_from_ulong);
+    specialize_stl_vector(unsigned int,scm_is_number,scm_to_ulong,scm_from_ulong);
+    specialize_stl_vector(unsigned long,scm_is_number,scm_to_ulong,scm_from_ulong);
+    specialize_stl_vector(unsigned short,scm_is_number,scm_to_ulong,scm_from_ulong);
+    specialize_stl_vector(float,scm_is_number,scm_to_double,scm_from_double);
+    specialize_stl_vector(double,scm_is_number,scm_to_double,scm_from_double);
+    specialize_stl_vector(std::string,scm_is_string,SWIG_scm2string,SWIG_string2scm);
+}
+
diff --git a/share/swig/2.0.11/guile/stl.i b/share/swig/3.0.12/guile/stl.i
index 9d2e91e..9d2e91e 100644
--- a/share/swig/2.0.11/guile/stl.i
+++ b/share/swig/3.0.12/guile/stl.i
diff --git a/share/swig/2.0.11/guile/swigrun.i b/share/swig/3.0.12/guile/swigrun.i
index 4b9ea2c..4b9ea2c 100644
--- a/share/swig/2.0.11/guile/swigrun.i
+++ b/share/swig/3.0.12/guile/swigrun.i
diff --git a/share/swig/3.0.12/guile/typemaps.i b/share/swig/3.0.12/guile/typemaps.i
new file mode 100644
index 0000000..a01e73f
--- /dev/null
+++ b/share/swig/3.0.12/guile/typemaps.i
@@ -0,0 +1,472 @@
+/* -----------------------------------------------------------------------------
+ * typemaps.i
+ *
+ * Guile-specific typemaps
+ * ----------------------------------------------------------------------------- */
+
+/* Pointers */
+
+%typemap(in) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] {
+  $1 = ($1_ltype)SWIG_MustGetPtr($input, $descriptor, $argnum, 0);
+}
+%typemap(freearg) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] "";
+
+%typemap(in) void * {
+  $1 = ($1_ltype)SWIG_MustGetPtr($input, NULL, $argnum, 0);
+}
+%typemap(freearg) void * "";
+
+%typemap(varin) SWIGTYPE * {
+  $1 = ($1_ltype)SWIG_MustGetPtr($input, $descriptor, 1, 0);
+}
+
+%typemap(varin) SWIGTYPE & {
+  $1 = *(($1_ltype)SWIG_MustGetPtr($input, $descriptor, 1, 0));
+}
+
+%typemap(varin) SWIGTYPE && {
+  $1 = *(($1_ltype)SWIG_MustGetPtr($input, $descriptor, 1, 0));
+}
+
+%typemap(varin) SWIGTYPE [] {
+  scm_wrong_type_arg((char *) FUNC_NAME, 1, $input);
+}
+
+%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 &&, SWIGTYPE [] {
+  $result = SWIG_NewPointerObj ($1, $descriptor, $owner);
+}
+
+%typemap(out) SWIGTYPE *DYNAMIC, SWIGTYPE &DYNAMIC {
+  swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor,(void **) &$1);
+  $result = SWIG_NewPointerObj ($1, ty, $owner);
+}
+    
+%typemap(varout) SWIGTYPE *, SWIGTYPE [] {
+  $result = SWIG_NewPointerObj ($1, $descriptor, 0);
+}
+
+%typemap(varout) SWIGTYPE & {
+  $result = SWIG_NewPointerObj((void *) &$1, $1_descriptor, 0);
+}
+
+%typemap(varout) SWIGTYPE && {
+  $result = SWIG_NewPointerObj((void *) &$1, $1_descriptor, 0);
+}
+
+%typemap(throws) SWIGTYPE {
+  $&ltype temp = new $ltype($1);
+  scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
+	    scm_listify(SWIG_NewPointerObj(temp, $&descriptor, 1),
+		    SCM_UNDEFINED));
+}
+
+%typemap(throws) SWIGTYPE & {
+  scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
+	    scm_listify(SWIG_NewPointerObj(&$1, $descriptor, 1),
+		    SCM_UNDEFINED));
+}
+
+%typemap(throws) SWIGTYPE && {
+  scm_throw(gh_symbol2scm((char *) "swig-exception"),
+	    gh_list(SWIG_NewPointerObj(&$1, $descriptor, 1),
+		    SCM_UNDEFINED));
+}
+
+%typemap(throws) SWIGTYPE * {
+  scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
+	    scm_listify(SWIG_NewPointerObj($1, $descriptor, 1),
+		    SCM_UNDEFINED));
+}
+
+%typemap(throws) SWIGTYPE [] {
+  scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
+	    scm_listify(SWIG_NewPointerObj($1, $descriptor, 1),
+		    SCM_UNDEFINED));
+}
+
+/* Change of object ownership, and interaction of destructor-like functions and the
+   garbage-collector */
+
+%typemap(in, doc="$NAME is of type <$type> and gets destroyed by the function") SWIGTYPE *DESTROYED {
+  $1 = ($1_ltype)SWIG_MustGetPtr($input, $descriptor, $argnum, 0);
+}
+
+%typemap(freearg) SWIGTYPE *DESTROYED {
+  SWIG_Guile_MarkPointerDestroyed($input);
+}
+
+%typemap(in, doc="$NAME is of type <$type> and is consumed by the function") SWIGTYPE *CONSUMED {
+  $1 = ($1_ltype)SWIG_MustGetPtr($input, $descriptor, $argnum, 0);
+  SWIG_Guile_MarkPointerNoncollectable($input);
+}
+
+/* Pass-by-value */
+
+%typemap(in) SWIGTYPE($&1_ltype argp) {
+  argp = ($&1_ltype)SWIG_MustGetPtr($input, $&1_descriptor, $argnum, 0);
+  $1 = *argp;
+}
+
+%typemap(varin) SWIGTYPE {
+  $&1_ltype argp;
+  argp = ($&1_ltype)SWIG_MustGetPtr($input, $&1_descriptor, 1, 0);
+  $1 = *argp;
+}
+
+%typemap(out) SWIGTYPE 
+#ifdef __cplusplus
+{
+  $&1_ltype resultptr;
+  resultptr = new $1_ltype((const $1_ltype &) $1);
+  $result =  SWIG_NewPointerObj (resultptr, $&1_descriptor, 1);
+} 
+#else
+{
+  $&1_ltype resultptr;
+  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;
+  resultptr = new $1_ltype((const $1_ltype&) $1);
+  $result =  SWIG_NewPointerObj (resultptr, $&1_descriptor, 0);
+} 
+#else
+{
+  $&1_ltype resultptr;
+  resultptr = ($&1_ltype) malloc(sizeof($1_type));
+  memmove(resultptr, &$1, sizeof($1_type));
+  $result = SWIG_NewPointerObj(resultptr, $&1_descriptor, 0);
+}
+#endif
+
+/* Enums */
+
+%typemap(in)     enum SWIGTYPE  { $1 = ($1_type) scm_to_int($input); }
+/* The complicated construction below needed to deal with anonymous
+   enums, which cannot be cast to. */
+%typemap(varin)  enum SWIGTYPE  {
+  if (sizeof(int) != sizeof($1)) {
+    scm_error(scm_from_locale_symbol("swig-error"),
+	      (char *) FUNC_NAME,
+	      (char *) "enum variable '$name' cannot be set",
+	      SCM_EOL, SCM_BOOL_F); 
+  }
+  * (int *) &($1) = scm_to_int($input);
+}
+%typemap(out)    enum SWIGTYPE  { $result = scm_from_long((int)$1); }
+%typemap(varout) enum SWIGTYPE  { $result = scm_from_long((int)$1); }
+%typemap(throws) enum SWIGTYPE {
+  scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
+     scm_listify(scm_from_long((int)$1), SCM_UNDEFINED));
+}
+
+/* The SIMPLE_MAP_WITH_EXPR macro below defines the whole set of
+   typemaps needed for simple types.
+   -- SCM_TO_C_EXPR is a C expression that translates the Scheme value
+      "swig_scm_value" to a C value.
+   -- C_TO_SCM_EXPR is a C expression that translates the C value
+      "swig_c_value" to a Scheme value. */
+
+%define SIMPLE_MAP_WITH_EXPR(C_NAME, SCM_TO_C_EXPR, C_TO_SCM_EXPR, SCM_NAME)
+ %typemap (in,     doc="$NAME is of type <" #SCM_NAME ">") C_NAME
+     { SCM swig_scm_value = $input;
+       $1 = SCM_TO_C_EXPR; }
+ %typemap (varin,  doc="NEW-VALUE is of type <" #SCM_NAME ">") C_NAME
+     { SCM swig_scm_value = $input;
+       $1 = SCM_TO_C_EXPR; }
+ %typemap (out,    doc="<" #SCM_NAME ">") C_NAME
+     { C_NAME swig_c_value = $1;
+       $result = C_TO_SCM_EXPR; }
+ %typemap (varout, doc="<" #SCM_NAME ">") C_NAME
+     { C_NAME swig_c_value = $1;
+       $result = C_TO_SCM_EXPR; }
+ /* INPUT and OUTPUT */
+ %typemap (in, doc="$NAME is of type <" #SCM_NAME ">)")
+     C_NAME *INPUT(C_NAME temp) {
+       SCM swig_scm_value = $input;
+       temp = (C_NAME) SCM_TO_C_EXPR; $1 = &temp; }
+ %typemap (in,numinputs=0)      C_NAME *OUTPUT (C_NAME temp)
+     {$1 = &temp;}
+ %typemap (argout,doc="$name (of type <" #SCM_NAME ">)") C_NAME *OUTPUT
+     { C_NAME swig_c_value = *$1;
+       SWIG_APPEND_VALUE(C_TO_SCM_EXPR); }
+ %typemap (in)          C_NAME *BOTH = C_NAME *INPUT;
+ %typemap (argout)      C_NAME *BOTH = C_NAME *OUTPUT;
+ %typemap (in)          C_NAME *INOUT = C_NAME *INPUT;
+ %typemap (argout)      C_NAME *INOUT = C_NAME *OUTPUT;
+ /* Const primitive references.  Passed by value */
+ %typemap(in, doc="$NAME is of type <" #SCM_NAME ">") const C_NAME & (C_NAME temp)
+     { SCM swig_scm_value = $input;
+       temp = SCM_TO_C_EXPR;
+       $1 = &temp; }
+ %typemap(out, doc="<" #SCM_NAME ">")  const C_NAME &
+     { C_NAME swig_c_value = *$1;
+       $result = C_TO_SCM_EXPR; }
+ /* Throw typemap */
+ %typemap(throws) C_NAME {
+   C_NAME swig_c_value = $1;
+   scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
+	     scm_listify(C_TO_SCM_EXPR, SCM_UNDEFINED));
+ }
+%enddef
+
+/* The SIMPLE_MAP macro below defines the whole set of typemaps needed
+   for simple types.  It generates slightly simpler code than the
+   macro above, but it is only suitable for very simple conversion
+   expressions. */
+
+%define SIMPLE_MAP(C_NAME, SCM_TO_C, C_TO_SCM, SCM_NAME)
+ %typemap (in,     doc="$NAME is of type <" #SCM_NAME ">")
+     C_NAME {$1 = ($1_ltype) SCM_TO_C($input);}
+ %typemap (varin,  doc="NEW-VALUE is of type <" #SCM_NAME ">")
+     C_NAME {$1 = ($1_ltype) SCM_TO_C($input);}
+ %typemap (out,    doc="<" #SCM_NAME ">")
+     C_NAME {$result = C_TO_SCM($1);}
+ %typemap (varout, doc="<" #SCM_NAME ">")
+     C_NAME {$result = C_TO_SCM($1);}
+ /* INPUT and OUTPUT */
+ %typemap (in, doc="$NAME is of type <" #SCM_NAME ">)")
+     C_NAME *INPUT(C_NAME temp), C_NAME &INPUT(C_NAME temp) {
+   temp = (C_NAME) SCM_TO_C($input); $1 = &temp;
+ }
+ %typemap (in,numinputs=0)      C_NAME *OUTPUT (C_NAME temp), C_NAME &OUTPUT(C_NAME temp)
+   {$1 = &temp;}
+ %typemap (argout,doc="$name (of type <" #SCM_NAME ">)") C_NAME *OUTPUT, C_NAME &OUTPUT
+   {SWIG_APPEND_VALUE(C_TO_SCM(*$1));}
+ %typemap (in)          C_NAME *BOTH = C_NAME *INPUT;
+ %typemap (argout)      C_NAME *BOTH = C_NAME *OUTPUT;
+ %typemap (in)          C_NAME *INOUT = C_NAME *INPUT;
+ %typemap (argout)      C_NAME *INOUT = C_NAME *OUTPUT;
+ %typemap (in)          C_NAME &INOUT = C_NAME &INPUT;
+ %typemap (argout)      C_NAME &INOUT = C_NAME &OUTPUT;
+ /* Const primitive references.  Passed by value */
+ %typemap(in, doc="$NAME is of type <" #SCM_NAME ">") const C_NAME & (C_NAME temp) {
+   temp = SCM_TO_C($input);
+   $1 = ($1_ltype) &temp;
+ }
+ %typemap(out, doc="<" #SCM_NAME ">")  const C_NAME & {
+   $result = C_TO_SCM(*$1);
+ }
+ /* Throw typemap */
+ %typemap(throws) C_NAME {
+   scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
+	     scm_listify(C_TO_SCM($1), SCM_UNDEFINED));
+ }
+%enddef
+
+ SIMPLE_MAP(bool, scm_is_true, scm_from_bool, boolean);
+ SIMPLE_MAP(char, SCM_CHAR, SCM_MAKE_CHAR, char);
+ SIMPLE_MAP(unsigned char, SCM_CHAR, SCM_MAKE_CHAR, char);
+ SIMPLE_MAP(signed char, SCM_CHAR, SCM_MAKE_CHAR, char);
+ SIMPLE_MAP(int, scm_to_int, scm_from_long, integer);
+ SIMPLE_MAP(short, scm_to_short, scm_from_long, integer);
+ SIMPLE_MAP(long, scm_to_long, scm_from_long, integer);
+ SIMPLE_MAP(ptrdiff_t, scm_to_long, scm_from_long, integer);
+ SIMPLE_MAP(unsigned int, scm_to_uint, scm_from_ulong, integer);
+ SIMPLE_MAP(unsigned short, scm_to_ushort, scm_from_ulong, integer);
+ SIMPLE_MAP(unsigned long, scm_to_ulong, scm_from_ulong, integer);
+ SIMPLE_MAP(size_t, scm_to_ulong, scm_from_ulong, integer);
+ SIMPLE_MAP(float, scm_to_double, scm_from_double, real);
+ SIMPLE_MAP(double, scm_to_double, scm_from_double, real);
+// SIMPLE_MAP(char *, SWIG_scm2str, SWIG_str02scm, string);
+// SIMPLE_MAP(const char *, SWIG_scm2str, SWIG_str02scm, string);
+
+/* Define long long typemaps -- uses functions that are only defined
+   in recent versions of Guile, availability also depends on Guile's
+   configuration. */
+
+SIMPLE_MAP(long long, scm_to_long_long, scm_from_long_long, integer);
+SIMPLE_MAP(unsigned long long, scm_to_ulong_long, scm_from_ulong_long, integer);
+
+/* Strings */
+
+ %typemap (in,     doc="$NAME is a string")      char *(int must_free = 0) {
+  $1 = ($1_ltype)SWIG_scm2str($input);
+  must_free = 1;
+ }
+ %typemap (varin,  doc="NEW-VALUE is a string")  char * {$1 = ($1_ltype)SWIG_scm2str($input);}
+ %typemap (out,    doc="<string>")              char * {$result = SWIG_str02scm((const char *)$1);}
+ %typemap (varout, doc="<string>")              char * {$result = SWIG_str02scm($1);}
+ %typemap (in, doc="$NAME is a string")          char **INPUT(char * temp, int must_free = 0) {
+   temp = (char *) SWIG_scm2str($input); $1 = &temp;
+   must_free = 1;
+ }
+ %typemap (in,numinputs=0)  char **OUTPUT (char * temp)
+   {$1 = &temp;}
+ %typemap (argout,doc="$NAME (a string)") char **OUTPUT
+   {SWIG_APPEND_VALUE(SWIG_str02scm(*$1));}
+ %typemap (in)          char **BOTH = char **INPUT;
+ %typemap (argout)      char **BOTH = char **OUTPUT;
+ %typemap (in)          char **INOUT = char **INPUT;
+ %typemap (argout)      char **INOUT = char **OUTPUT;
+
+/* SWIG_scm2str makes a malloc'ed copy of the string, so get rid of it after
+   the function call. */
+
+%typemap (freearg) char * "if (must_free$argnum && $1) SWIG_free($1);";
+%typemap (freearg) char **INPUT, char **BOTH "if (must_free$argnum && (*$1)) SWIG_free(*$1);"
+%typemap (freearg) char **OUTPUT "SWIG_free(*$1);"
+  
+/* But this shall not apply if we try to pass a single char by
+   reference. */
+
+%typemap (freearg) char *OUTPUT, char *BOTH "";
+
+/* If we set a string variable, delete the old result first, unless const. */
+
+%typemap (varin) char * {
+    if ($1) free($1);
+    $1 = ($1_ltype) SWIG_scm2str($input);
+}
+
+%typemap (varin) const char * {
+    $1 = ($1_ltype) SWIG_scm2str($input);
+}
+
+%typemap(throws) char * {
+  scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
+	    scm_listify(SWIG_str02scm($1), SCM_UNDEFINED));
+}
+
+/* Void */
+
+%typemap (out,doc="") void "gswig_result = SCM_UNSPECIFIED;";
+
+/* SCM is passed through */
+
+typedef unsigned long SCM;
+%typemap (in) SCM "$1=$input;";
+%typemap (out) SCM "$result=$1;";
+%typecheck(SWIG_TYPECHECK_POINTER) SCM "$1=1;";
+
+/* ------------------------------------------------------------
+ * String & length
+ * ------------------------------------------------------------ */
+
+%typemap(in) (char *STRING, int LENGTH), (char *STRING, size_t LENGTH) {
+    size_t temp;
+    $1 = ($1_ltype) SWIG_Guile_scm2newstr($input, &temp);
+    $2 = ($2_ltype) temp;
+}
+
+/* ------------------------------------------------------------
+ * CLASS::* (member function pointer) typemaps
+ * taken from typemaps/swigtype.swg
+ * ------------------------------------------------------------ */
+
+#define %set_output(obj)                  $result = obj
+#define %set_varoutput(obj)               $result = obj
+#define %argument_fail(code, type, name, argn)	scm_wrong_type_arg((char *) FUNC_NAME, argn, $input);
+#define %as_voidptr(ptr)		(void*)(ptr)
+
+%typemap(in) SWIGTYPE (CLASS::*) {  
+  int res = SWIG_ConvertMember($input, %as_voidptr(&$1), sizeof($type),$descriptor);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res,"$type",$symname, $argnum); 
+  }
+}
+
+%typemap(out,noblock=1) SWIGTYPE (CLASS::*) {
+  %set_output(SWIG_NewMemberObj(%as_voidptr(&$1), sizeof($type), $descriptor));
+}
+
+%typemap(varin) SWIGTYPE (CLASS::*) {
+  int res = SWIG_ConvertMember($input,%as_voidptr(&$1), sizeof($type), $descriptor);
+  if (!SWIG_IsOK(res)) {
+    scm_wrong_type_arg((char *) FUNC_NAME, 1, $input);
+  }
+}
+
+%typemap(varout,noblock=1) SWIGTYPE (CLASS::*) {
+  %set_varoutput(SWIG_NewMemberObj(%as_voidptr(&$1), sizeof($type), $descriptor));
+}
+
+/* ------------------------------------------------------------
+ * Typechecking rules
+ * ------------------------------------------------------------ */
+
+/* adapted from python.swg */
+
+%typecheck(SWIG_TYPECHECK_INTEGER)
+	 int, short, long,
+ 	 unsigned int, unsigned short, unsigned long,
+	 signed char, unsigned char,
+	 long long, unsigned long long,
+         size_t, ptrdiff_t,
+         std::size_t, std::ptrdiff_t,
+	 const int &, const short &, const long &,
+ 	 const unsigned int &, const unsigned short &, const unsigned long &,
+	 const long long &, const unsigned long long &,
+         const size_t &, const ptrdiff_t &,
+         const std::size_t &, const std::ptrdiff_t &,
+	 enum SWIGTYPE
+{
+  $1 = scm_is_true(scm_integer_p($input)) && scm_is_true(scm_exact_p($input))? 1 : 0;
+}
+
+%typecheck(SWIG_TYPECHECK_BOOL)
+	bool, bool&, const bool&
+{
+  $1 = SCM_BOOLP($input) ? 1 : 0;
+}
+
+%typecheck(SWIG_TYPECHECK_DOUBLE)
+	float, double,
+	const float &, const double &
+{
+  $1 = scm_is_true(scm_real_p($input)) ? 1 : 0;
+}
+
+%typecheck(SWIG_TYPECHECK_CHAR) char {
+  $1 = SCM_CHARP($input) ? 1 : 0;
+}
+
+%typecheck(SWIG_TYPECHECK_STRING) char * {
+  $1 = scm_is_string($input) ? 1 : 0;
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] {
+  void *ptr;
+  int res = SWIG_ConvertPtr($input, &ptr, $1_descriptor, 0);
+  $1 = SWIG_CheckState(res);
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE {
+  void *ptr;
+  int res = SWIG_ConvertPtr($input, &ptr, $&descriptor, 0);
+  $1 = SWIG_CheckState(res);
+}
+
+%typecheck(SWIG_TYPECHECK_VOIDPTR) void * {
+  void *ptr;
+  int res = SWIG_ConvertPtr($input, &ptr, 0, 0);
+  $1 = SWIG_CheckState(res);
+}
+
+/* Array reference typemaps */
+%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) }
+
+/* const pointers */
+%apply SWIGTYPE * { SWIGTYPE *const }
+
+/* typemaps.i ends here */
diff --git a/share/swig/2.0.11/intrusive_ptr.i b/share/swig/3.0.12/intrusive_ptr.i
index ceaeaf0..ceaeaf0 100644
--- a/share/swig/2.0.11/intrusive_ptr.i
+++ b/share/swig/3.0.12/intrusive_ptr.i
diff --git a/share/swig/3.0.12/inttypes.i b/share/swig/3.0.12/inttypes.i
new file mode 100644
index 0000000..85bd5ad
--- /dev/null
+++ b/share/swig/3.0.12/inttypes.i
@@ -0,0 +1,85 @@
+/* -----------------------------------------------------------------------------
+ * inttypes.i
+ *
+ * SWIG library file  for ISO C99 types: 7.8 Format conversion of integer types <inttypes.h>
+ * ----------------------------------------------------------------------------- */
+
+%{
+#include <inttypes.h>
+%}
+
+%include <stdint.i>
+%include <wchar.i>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef SWIGWORDSIZE64
+  
+  /* We have to define the `uintmax_t' type using `ldiv_t'.  */
+  typedef struct
+  {
+    long int quot;		/* Quotient.  */
+    long int rem;		/* Remainder.  */
+  } imaxdiv_t;
+  
+#else
+  
+  /* We have to define the `uintmax_t' type using `lldiv_t'.  */
+  typedef struct
+  {
+    long long int quot;		/* Quotient.  */
+    long long int rem;		/* Remainder.  */
+  } imaxdiv_t;
+
+#endif
+
+  /* Compute absolute value of N.  */
+  extern intmax_t imaxabs (intmax_t n);
+
+  /* Return the `imaxdiv_t' representation of the value of NUMER over DENOM. */
+  extern imaxdiv_t imaxdiv (intmax_t numer, intmax_t denom);
+  
+#ifdef SWIG_WCHAR
+  /* Like `wcstol' but convert to `intmax_t'.  */
+  extern intmax_t wcstoimax (const wchar_t *nptr, wchar_t **endptr, int base);
+  
+  /* Like `wcstoul' but convert to `uintmax_t'.  */
+  extern uintmax_t wcstoumax (const wchar_t *nptr, wchar_t ** endptr, int base);
+#endif
+
+#ifdef SWIGWORDSIZE64
+  
+  /* Like `strtol' but convert to `intmax_t'.  */
+  extern  intmax_t strtoimax (const char *nptr, char **endptr, int base);
+  
+  /* Like `strtoul' but convert to `uintmax_t'.  */
+  extern  uintmax_t strtoumax (const char *nptr, char **endptr,int base);
+  
+#ifdef SWIG_WCHAR
+  /* Like `wcstol' but convert to `intmax_t'.  */
+  extern  intmax_t wcstoimax (const wchar_t *nptr, wchar_t **endptr, int base);
+  
+  /* Like `wcstoul' but convert to `uintmax_t'.  */
+  extern  uintmax_t wcstoumax (const wchar_t *nptr, wchar_t **endptr, int base);
+#endif
+  
+#else /* SWIGWORDSIZE32 */
+  
+  /* Like `strtol' but convert to `intmax_t'.  */
+  extern  intmax_t strtoimax (const char *nptr, char **endptr, int base);
+  
+  /* Like `strtoul' but convert to `uintmax_t'.  */
+  extern  uintmax_t strtoumax (const char *nptr, char **endptr, int base);
+  
+#ifdef SWIG_WCHAR
+  /* Like `wcstol' but convert to `intmax_t'.  */
+  extern  uintmax_t wcstoumax (const wchar_t *nptr, wchar_t **endptr, int base);
+#endif
+
+#endif /* SWIGWORDSIZE64 */
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/share/swig/3.0.12/java/arrays_java.i b/share/swig/3.0.12/java/arrays_java.i
new file mode 100644
index 0000000..dd38438
--- /dev/null
+++ b/share/swig/3.0.12/java/arrays_java.i
@@ -0,0 +1,392 @@
+/* -----------------------------------------------------------------------------
+ * arrays_java.i
+ *
+ * These typemaps give more natural support for arrays. The typemaps are not efficient
+ * as there is a lot of copying of the array values whenever the array is passed to C/C++ 
+ * from Java and vice versa. The Java array is expected to be the same size as the C array.
+ * An exception is thrown if they are not.
+ *
+ * Example usage:
+ * Wrapping:
+ *
+ *   %include <arrays_java.i>
+ *   %inline %{
+ *       short FiddleSticks[3];
+ *   %}
+ *
+ * Use from Java like this:
+ *
+ *   short[] fs = new short[] {10, 11, 12};
+ *   example.setFiddleSticks(fs);
+ *   fs = example.getFiddleSticks();
+ * ----------------------------------------------------------------------------- */
+
+/* Primitive array support is a combination of SWIG macros and functions in order to reduce 
+ * code bloat and aid maintainability. The SWIG preprocessor expands the macros into functions 
+ * for inclusion in the generated code. */
+
+/* Array support functions declarations macro */
+%define JAVA_ARRAYS_DECL(CTYPE, JNITYPE, JAVATYPE, JFUNCNAME)
+%{
+static int SWIG_JavaArrayIn##JFUNCNAME (JNIEnv *jenv, JNITYPE **jarr, CTYPE **carr, JNITYPE##Array input);
+static void SWIG_JavaArrayArgout##JFUNCNAME (JNIEnv *jenv, JNITYPE *jarr, CTYPE *carr, JNITYPE##Array input);
+static JNITYPE##Array SWIG_JavaArrayOut##JFUNCNAME (JNIEnv *jenv, CTYPE *result, jsize sz);
+%}
+%enddef
+
+/* Array support functions macro */
+%define JAVA_ARRAYS_IMPL(CTYPE, JNITYPE, JAVATYPE, JFUNCNAME)
+%{
+/* CTYPE[] support */
+static int SWIG_JavaArrayIn##JFUNCNAME (JNIEnv *jenv, JNITYPE **jarr, CTYPE **carr, JNITYPE##Array input) {
+  int i;
+  jsize sz;
+  if (!input) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
+    return 0;
+  }
+  sz = JCALL1(GetArrayLength, jenv, input);
+  *jarr = JCALL2(Get##JAVATYPE##ArrayElements, jenv, input, 0);
+  if (!*jarr)
+    return 0; %}
+#ifdef __cplusplus
+%{  *carr = new CTYPE[sz]; %}
+#else
+%{  *carr = (CTYPE*) malloc(sz * sizeof(CTYPE)); %}
+#endif
+%{  if (!*carr) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
+    return 0;
+  }
+  for (i=0; i<sz; i++)
+    JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN(CTYPE)
+  return 1;
+}
+
+static void SWIG_JavaArrayArgout##JFUNCNAME (JNIEnv *jenv, JNITYPE *jarr, CTYPE *carr, JNITYPE##Array input) {
+  int i;
+  jsize sz = JCALL1(GetArrayLength, jenv, input);
+  for (i=0; i<sz; i++)
+    jarr[i] = (JNITYPE)carr[i];
+  JCALL3(Release##JAVATYPE##ArrayElements, jenv, input, jarr, 0);
+}
+
+static JNITYPE##Array SWIG_JavaArrayOut##JFUNCNAME (JNIEnv *jenv, CTYPE *result, jsize sz) {
+  JNITYPE *arr;
+  int i;
+  JNITYPE##Array jresult = JCALL1(New##JAVATYPE##Array, jenv, sz);
+  if (!jresult)
+    return NULL;
+  arr = JCALL2(Get##JAVATYPE##ArrayElements, jenv, jresult, 0);
+  if (!arr)
+    return NULL;
+  for (i=0; i<sz; i++)
+    arr[i] = (JNITYPE)result[i];
+  JCALL3(Release##JAVATYPE##ArrayElements, jenv, jresult, arr, 0);
+  return jresult;
+}
+%}
+%enddef
+
+%{
+#if defined(SWIG_NOINCLUDE) || defined(SWIG_NOARRAYS)
+%}
+
+#ifdef __cplusplus
+JAVA_ARRAYS_DECL(bool, jboolean, Boolean, Bool)       /* bool[] */
+#endif
+
+JAVA_ARRAYS_DECL(signed char, jbyte, Byte, Schar)     /* signed char[] */
+JAVA_ARRAYS_DECL(unsigned char, jshort, Short, Uchar) /* unsigned char[] */
+JAVA_ARRAYS_DECL(short, jshort, Short, Short)         /* short[] */
+JAVA_ARRAYS_DECL(unsigned short, jint, Int, Ushort)   /* unsigned short[] */
+JAVA_ARRAYS_DECL(int, jint, Int, Int)                 /* int[] */
+JAVA_ARRAYS_DECL(unsigned int, jlong, Long, Uint)     /* unsigned int[] */
+JAVA_ARRAYS_DECL(long, jint, Int, Long)               /* long[] */
+JAVA_ARRAYS_DECL(unsigned long, jlong, Long, Ulong)   /* unsigned long[] */
+JAVA_ARRAYS_DECL(jlong, jlong, Long, Longlong)        /* long long[] */
+JAVA_ARRAYS_DECL(float, jfloat, Float, Float)         /* float[] */
+JAVA_ARRAYS_DECL(double, jdouble, Double, Double)     /* double[] */
+
+%{
+#else
+%}
+
+#ifdef __cplusplus
+/* Bool array element assignment different to other types to keep Visual C++ quiet */
+#define JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN(CTYPE) (*carr)[i] = ((*jarr)[i] != 0);
+JAVA_ARRAYS_IMPL(bool, jboolean, Boolean, Bool)       /* bool[] */
+#undef JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN
+#endif
+
+#define JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN(CTYPE) (*carr)[i] = (CTYPE)(*jarr)[i];
+JAVA_ARRAYS_IMPL(signed char, jbyte, Byte, Schar)     /* signed char[] */
+JAVA_ARRAYS_IMPL(unsigned char, jshort, Short, Uchar) /* unsigned char[] */
+JAVA_ARRAYS_IMPL(short, jshort, Short, Short)         /* short[] */
+JAVA_ARRAYS_IMPL(unsigned short, jint, Int, Ushort)   /* unsigned short[] */
+JAVA_ARRAYS_IMPL(int, jint, Int, Int)                 /* int[] */
+JAVA_ARRAYS_IMPL(unsigned int, jlong, Long, Uint)     /* unsigned int[] */
+JAVA_ARRAYS_IMPL(long, jint, Int, Long)               /* long[] */
+JAVA_ARRAYS_IMPL(unsigned long, jlong, Long, Ulong)   /* unsigned long[] */
+JAVA_ARRAYS_IMPL(jlong, jlong, Long, Longlong)        /* long long[] */
+JAVA_ARRAYS_IMPL(float, jfloat, Float, Float)         /* float[] */
+JAVA_ARRAYS_IMPL(double, jdouble, Double, Double)     /* double[] */
+
+%{
+#endif
+%}
+
+
+/* The rest of this file has the array typemaps */
+
+/* Arrays of primitive types use the following macro. The array typemaps use support functions. */
+%define JAVA_ARRAYS_TYPEMAPS(CTYPE, JTYPE, JNITYPE, JFUNCNAME, JNIDESC)
+
+%typemap(jni) CTYPE[ANY], CTYPE[]               %{JNITYPE##Array%}
+%typemap(jtype) CTYPE[ANY], CTYPE[]             %{JTYPE[]%}
+%typemap(jstype) CTYPE[ANY], CTYPE[]            %{JTYPE[]%}
+
+%typemap(in) CTYPE[] (JNITYPE *jarr)
+%{  if (!SWIG_JavaArrayIn##JFUNCNAME(jenv, &jarr, (CTYPE **)&$1, $input)) return $null; %}
+%typemap(in) CTYPE[ANY] (JNITYPE *jarr)
+%{  if ($input && JCALL1(GetArrayLength, jenv, $input) != $1_size) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
+    return $null;
+  }
+  if (!SWIG_JavaArrayIn##JFUNCNAME(jenv, &jarr, (CTYPE **)&$1, $input)) return $null; %}
+%typemap(argout) CTYPE[ANY], CTYPE[] 
+%{ SWIG_JavaArrayArgout##JFUNCNAME(jenv, jarr$argnum, (CTYPE *)$1, $input); %}
+%typemap(out) CTYPE[ANY]
+%{$result = SWIG_JavaArrayOut##JFUNCNAME(jenv, (CTYPE *)$1, $1_dim0); %}
+%typemap(out) CTYPE[] 
+%{$result = SWIG_JavaArrayOut##JFUNCNAME(jenv, (CTYPE *)$1, FillMeInAsSizeCannotBeDeterminedAutomatically); %}
+%typemap(freearg) CTYPE[ANY], CTYPE[] 
+#ifdef __cplusplus
+%{ delete [] $1; %}
+#else
+%{ free($1); %}
+#endif
+
+%typemap(javain) CTYPE[ANY], CTYPE[] "$javainput"
+%typemap(javaout) CTYPE[ANY], CTYPE[] {
+    return $jnicall;
+  }
+
+%typemap(memberin) CTYPE[ANY], CTYPE[];
+%typemap(globalin) CTYPE[ANY], CTYPE[];
+%enddef
+
+JAVA_ARRAYS_TYPEMAPS(bool, boolean, jboolean, Bool, "[Z")       /* bool[ANY] */
+JAVA_ARRAYS_TYPEMAPS(signed char, byte, jbyte, Schar, "[B")     /* signed char[ANY] */
+JAVA_ARRAYS_TYPEMAPS(unsigned char, short, jshort, Uchar, "[S") /* unsigned char[ANY] */
+JAVA_ARRAYS_TYPEMAPS(short, short, jshort, Short, "[S")         /* short[ANY] */
+JAVA_ARRAYS_TYPEMAPS(unsigned short, int, jint, Ushort, "[I")   /* unsigned short[ANY] */
+JAVA_ARRAYS_TYPEMAPS(int, int, jint, Int, "[I")                 /* int[ANY] */
+JAVA_ARRAYS_TYPEMAPS(unsigned int, long, jlong, Uint, "[J")     /* unsigned int[ANY] */
+JAVA_ARRAYS_TYPEMAPS(long, int, jint, Long, "[I")               /* long[ANY] */
+JAVA_ARRAYS_TYPEMAPS(unsigned long, long, jlong, Ulong, "[J")   /* unsigned long[ANY] */
+JAVA_ARRAYS_TYPEMAPS(long long, long, jlong, Longlong, "[J")    /* long long[ANY] */
+JAVA_ARRAYS_TYPEMAPS(float, float, jfloat, Float, "[F")         /* float[ANY] */
+JAVA_ARRAYS_TYPEMAPS(double, double, jdouble, Double, "[D")     /* double[ANY] */
+
+
+%typecheck(SWIG_TYPECHECK_BOOL_ARRAY) /* Java boolean[] */
+    bool[ANY], bool[]
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT8_ARRAY) /* Java byte[] */
+    signed char[ANY], signed char[]
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT16_ARRAY) /* Java short[] */
+    unsigned char[ANY], unsigned char[],
+    short[ANY], short[]
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT32_ARRAY) /* Java int[] */
+    unsigned short[ANY], unsigned short[],
+    int[ANY], int[],
+    long[ANY], long[]
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT64_ARRAY) /* Java long[] */
+    unsigned int[ANY], unsigned int[],
+    unsigned long[ANY], unsigned long[],
+    long long[ANY], long long[]
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT128_ARRAY) /* Java BigInteger[] */
+    unsigned long long[ANY], unsigned long long[]
+    ""
+
+%typecheck(SWIG_TYPECHECK_FLOAT_ARRAY) /* Java float[] */
+    float[ANY], float[]
+    ""
+
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY) /* Java double[] */
+    double[ANY], double[]
+    ""
+
+
+/* Arrays of proxy classes. The typemaps in this macro make it possible to treat an array of 
+ * class/struct/unions as an array of Java classes. 
+ * Use the following macro to use these typemaps for an array of class/struct/unions called name:
+ * JAVA_ARRAYSOFCLASSES(name) 
+ * Note that multiple copies of the class/struct is made when using the array as a parameter input. */
+%define JAVA_ARRAYSOFCLASSES(ARRAYSOFCLASSES)
+
+%typemap(jni) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[] "jlongArray"
+%typemap(jtype) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[] "long[]"
+%typemap(jstype) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[] "$javaclassname[]"
+
+%typemap(javain) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[] "$javaclassname.cArrayUnwrap($javainput)"
+%typemap(javaout) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[] {
+    return $javaclassname.cArrayWrap($jnicall, $owner);
+  }
+
+%typemap(in) ARRAYSOFCLASSES[] (jlong *jarr, jsize sz)
+{
+  int i;
+  if (!$input) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
+    return $null;
+  }
+  sz = JCALL1(GetArrayLength, jenv, $input);
+  jarr = JCALL2(GetLongArrayElements, jenv, $input, 0);
+  if (!jarr) {
+    return $null;
+  }
+#ifdef __cplusplus
+  $1 = new $*1_ltype[sz];
+#else
+  $1 = ($1_ltype) malloc(sz * sizeof($*1_ltype));
+#endif
+  if (!$1) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
+    return $null;
+  }
+  for (i=0; i<sz; i++) {
+    $1[i] = **($&1_ltype)&jarr[i];
+  }
+}
+
+%typemap(in) ARRAYSOFCLASSES[ANY] (jlong *jarr, jsize sz)
+{
+  int i;
+  if (!$input) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
+    return $null;
+  }
+  sz = JCALL1(GetArrayLength, jenv, $input);
+  if (sz != $1_size) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
+    return $null;
+  }
+  jarr = JCALL2(GetLongArrayElements, jenv, $input, 0);
+  if (!jarr) {
+    return $null;
+  }
+#ifdef __cplusplus
+  $1 = new $*1_ltype[sz];
+#else
+  $1 = ($1_ltype) malloc(sz * sizeof($*1_ltype));
+#endif
+  if (!$1) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
+    return $null;
+  }
+  for (i=0; i<sz; i++) {
+    $1[i] = **($&1_ltype)&jarr[i];
+  }
+}
+
+%typemap(argout) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[]
+{
+  int i;
+  for (i=0; i<sz$argnum; i++) {
+    **($&1_ltype)&jarr$argnum[i] = $1[i];
+  }
+  JCALL3(ReleaseLongArrayElements, jenv, $input, jarr$argnum, 0);
+}
+
+%typemap(out) ARRAYSOFCLASSES[ANY]
+{
+  jlong *arr;
+  int i;
+  $result = JCALL1(NewLongArray, jenv, $1_dim0);
+  if (!$result) {
+    return $null;
+  }
+  arr = JCALL2(GetLongArrayElements, jenv, $result, 0);
+  if (!arr) {
+    return $null;
+  }
+  for (i=0; i<$1_dim0; i++) {
+    arr[i] = 0;
+    *($&1_ltype)&arr[i] = &$1[i];
+  }
+  JCALL3(ReleaseLongArrayElements, jenv, $result, arr, 0);
+}
+
+%typemap(freearg) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[]
+#ifdef __cplusplus
+%{ delete [] $1; %}
+#else
+%{ free($1); %}
+#endif
+
+/* Add some code to the proxy class of the array type for converting between type used in 
+ * JNI class (long[]) and type used in proxy class ( ARRAYSOFCLASSES[] ) */
+%extend ARRAYSOFCLASSES {
+%proxycode %{
+  protected static long[] cArrayUnwrap($javaclassname[] arrayWrapper) {
+      long[] cArray = new long[arrayWrapper.length];
+      for (int i=0; i<arrayWrapper.length; i++)
+        cArray[i] = $javaclassname.getCPtr(arrayWrapper[i]);
+      return cArray;
+  }
+
+  protected static $javaclassname[] cArrayWrap(long[] cArray, boolean cMemoryOwn) {
+    $javaclassname[] arrayWrapper = new $javaclassname[cArray.length];
+    for (int i=0; i<cArray.length; i++)
+      arrayWrapper[i] = new $javaclassname(cArray[i], cMemoryOwn);
+    return arrayWrapper;
+  }
+%}
+}
+
+%enddef /* JAVA_ARRAYSOFCLASSES */
+
+
+/* Arrays of enums. 
+ * Use the following to use these typemaps for an array of enums called name:
+ * %apply ARRAYSOFENUMS[ANY] { name[ANY] }; */
+%typemap(jni) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] "jintArray"
+%typemap(jtype) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] "int[]"
+%typemap(jstype) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] "int[]"
+
+%typemap(javain) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] "$javainput"
+%typemap(javaout) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] {
+    return $jnicall;
+  }
+
+%typemap(in) ARRAYSOFENUMS[] (jint *jarr)
+%{  if (!SWIG_JavaArrayInInt(jenv, &jarr, (int **)&$1, $input)) return $null; %}
+%typemap(in) ARRAYSOFENUMS[ANY] (jint *jarr) {
+  if ($input && JCALL1(GetArrayLength, jenv, $input) != $1_size) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
+    return $null;
+  }
+  if (!SWIG_JavaArrayInInt(jenv, &jarr, (int **)&$1, $input)) return $null;
+}
+%typemap(argout) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] 
+%{ SWIG_JavaArrayArgoutInt(jenv, jarr$argnum, (int *)$1, $input); %}
+%typemap(out) ARRAYSOFENUMS[ANY] 
+%{$result = SWIG_JavaArrayOutInt(jenv, (int *)$1, $1_dim0); %}
+%typemap(freearg) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] 
+#ifdef __cplusplus
+%{ delete [] $1; %}
+#else
+%{ free($1); %}
+#endif
+
diff --git a/share/swig/3.0.12/java/boost_intrusive_ptr.i b/share/swig/3.0.12/java/boost_intrusive_ptr.i
new file mode 100644
index 0000000..a484a3b
--- /dev/null
+++ b/share/swig/3.0.12/java/boost_intrusive_ptr.i
@@ -0,0 +1,473 @@
+// 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_NO_WRAP
+#define SWIG_INTRUSIVE_PTR_TYPEMAPS_NO_WRAP(CONST, TYPE...) SWIG_INTRUSIVE_PTR_TYPEMAPS_NO_WRAP_IMPLEMENTATION(protected, protected, CONST, TYPE)
+#endif
+#ifndef SWIG_INTRUSIVE_PTR_TYPEMAPS
+#define SWIG_INTRUSIVE_PTR_TYPEMAPS(CONST, TYPE...) SWIG_INTRUSIVE_PTR_TYPEMAPS_IMPLEMENTATION(protected, protected, 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) 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_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null $1_type");
+    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) 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) 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_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null");
+    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 > ($&1_type argp, 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(result.get());
+  	*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(result.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 (jni)    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 > *& "jlong"
+%typemap (jtype)  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 > *& "long"
+%typemap (jstype) 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(jstype, TYPE)"
+%typemap(javain) 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(jstype, TYPE).getCPtr($javainput)"
+
+%typemap(javaout) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > {
+    long cPtr = $jnicall;
+    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
+  }
+%typemap(javaout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
+    long cPtr = $jnicall;
+    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
+  }
+%typemap(javaout) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > & {
+    long cPtr = $jnicall;
+    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
+  }
+%typemap(javaout) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > * {
+    long cPtr = $jnicall;
+    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
+  }
+%typemap(javaout) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *& {
+    long cPtr = $jnicall;
+    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
+  }
+
+
+%typemap(javaout) CONST TYPE {
+    return new $typemap(jstype, TYPE)($jnicall, true);
+  }
+%typemap(javaout) CONST TYPE & {
+    return new $typemap(jstype, TYPE)($jnicall, true);
+  }
+%typemap(javaout) CONST TYPE * {
+    long cPtr = $jnicall;
+    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
+  }
+%typemap(javaout) TYPE *CONST& {
+    long cPtr = $jnicall;
+    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
+  }
+
+// Base proxy classes
+%typemap(javabody) TYPE %{
+  private transient long swigCPtr;
+  private transient boolean swigCMemOwnBase;
+
+  PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
+    swigCMemOwnBase = cMemoryOwn;
+    swigCPtr = cPtr;
+  }
+
+  CPTR_VISIBILITY static long getCPtr($javaclassname obj) {
+    return (obj == null) ? 0 : obj.swigCPtr;
+  }
+%}
+
+// Derived proxy classes
+%typemap(javabody_derived) TYPE %{
+  private transient long swigCPtr;
+  private transient boolean swigCMemOwnDerived;
+
+  PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
+    super($imclassname.$javaclazznameSWIGSmartPtrUpcast(cPtr), true);
+    swigCMemOwnDerived = cMemoryOwn;
+    swigCPtr = cPtr;
+  }
+
+  CPTR_VISIBILITY static long getCPtr($javaclassname obj) {
+    return (obj == null) ? 0 : obj.swigCPtr;
+  }
+%}
+
+%typemap(javadestruct, methodname="delete", methodmodifiers="public synchronized") TYPE {
+    if(swigCPtr != 0 && swigCMemOwnBase) {
+      swigCMemOwnBase = false;
+      $jnicall;
+    }
+    swigCPtr = 0;
+  }
+
+%typemap(javadestruct_derived, methodname="delete", methodmodifiers="public synchronized") TYPE {
+    if(swigCPtr != 0 && swigCMemOwnDerived) {
+      swigCMemOwnDerived = false;
+      $jnicall;
+    }
+    swigCPtr = 0;
+    super.delete();
+  }
+
+// CONST version needed ???? also for C#
+%typemap(jtype, nopgcpp="1") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > swigSharedPtrUpcast "long"
+%typemap(jtype, nopgcpp="1") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > swigSharedPtrUpcast "long"
+
+
+%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) 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_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null $1_type");
+    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) 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_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null");
+    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 (jni)    SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > "jlong"
+%typemap (jtype)  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > "long"
+%typemap (jstype) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > "$typemap(jstype, TYPE)"
+%typemap (javain) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > "$typemap(jstype, TYPE).getCPtr($javainput)"
+%typemap(javaout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
+    long cPtr = $jnicall;
+    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
+  }
+
+%typemap(javaout) CONST TYPE {
+    return new $typemap(jstype, TYPE)($jnicall, true);
+  }
+%typemap(javaout) CONST TYPE & {
+    return new $typemap(jstype, TYPE)($jnicall, true);
+  }
+%typemap(javaout) CONST TYPE * {
+    long cPtr = $jnicall;
+    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
+  }
+%typemap(javaout) TYPE *CONST& {
+    long cPtr = $jnicall;
+    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
+  }
+
+// Base proxy classes
+%typemap(javabody) TYPE %{
+  private transient long swigCPtr;
+  private transient boolean swigCMemOwnBase;
+
+  PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
+    swigCMemOwnBase = cMemoryOwn;
+    swigCPtr = cPtr;
+  }
+
+  CPTR_VISIBILITY static long getCPtr($javaclassname obj) {
+    return (obj == null) ? 0 : obj.swigCPtr;
+  }
+%}
+
+// Derived proxy classes
+%typemap(javabody_derived) TYPE %{
+  private transient long swigCPtr;
+  private transient boolean swigCMemOwnDerived;
+
+  PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
+    super($imclassname.$javaclazznameSWIGSmartPtrUpcast(cPtr), true);
+    swigCMemOwnDerived = cMemoryOwn;
+    swigCPtr = cPtr;
+  }
+
+  CPTR_VISIBILITY static long getCPtr($javaclassname obj) {
+    return (obj == null) ? 0 : obj.swigCPtr;
+  }
+%}
+
+%typemap(javadestruct, methodname="delete", methodmodifiers="public synchronized") TYPE {
+    if (swigCPtr != 0) {
+      if (swigCMemOwnBase) {
+        swigCMemOwnBase = false;
+        $jnicall;
+      }
+      swigCPtr = 0;
+    }
+  }
+
+%typemap(javadestruct_derived, methodname="delete", methodmodifiers="public synchronized") TYPE {
+    if (swigCPtr != 0) {
+      if (swigCMemOwnDerived) {
+        swigCMemOwnDerived = false;
+        $jnicall;
+      }
+      swigCPtr = 0;
+    }
+    super.delete();
+  }
+
+// CONST version needed ???? also for C#
+%typemap(jtype, nopgcpp="1") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > swigSharedPtrUpcast "long"
+%typemap(jtype, nopgcpp="1") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > swigSharedPtrUpcast "long"
+
+
+%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
+%enddef
+
diff --git a/share/swig/3.0.12/java/boost_shared_ptr.i b/share/swig/3.0.12/java/boost_shared_ptr.i
new file mode 100644
index 0000000..5ed16aa
--- /dev/null
+++ b/share/swig/3.0.12/java/boost_shared_ptr.i
@@ -0,0 +1,201 @@
+// 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(protected, protected, 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 wrapper customisation
+%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) 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_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null $1_type");
+    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) 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_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null");
+    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 = (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&
+%{ *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$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 > ($&1_type argp)
+%{ argp = *($&1_ltype*)&$input; 
+   if (argp) $1 = *argp; %}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >
+%{ *($&1_ltype*)&$result = $1 ? new $1_ltype($1) : 0; %}
+
+// shared_ptr by reference
+%typemap(in) 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 > &
+%{ *($&1_ltype)&$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) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *
+%{ *($&1_ltype)&$result = ($1 && *$1) ? new $*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 (jni)    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 > *& "jlong"
+%typemap (jtype)  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 > *& "long"
+%typemap (jstype) 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(jstype, TYPE)"
+
+%typemap(javain) 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(jstype, TYPE).getCPtr($javainput)"
+
+%typemap(javaout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
+    long cPtr = $jnicall;
+    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
+  }
+%typemap(javaout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & {
+    long cPtr = $jnicall;
+    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
+  }
+%typemap(javaout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * {
+    long cPtr = $jnicall;
+    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
+  }
+%typemap(javaout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& {
+    long cPtr = $jnicall;
+    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
+  }
+
+
+%typemap(javaout) CONST TYPE {
+    return new $typemap(jstype, TYPE)($jnicall, true);
+  }
+%typemap(javaout) CONST TYPE & {
+    return new $typemap(jstype, TYPE)($jnicall, true);
+  }
+%typemap(javaout) CONST TYPE * {
+    long cPtr = $jnicall;
+    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
+  }
+%typemap(javaout) TYPE *CONST& {
+    long cPtr = $jnicall;
+    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
+  }
+
+// Base proxy classes
+%typemap(javabody) TYPE %{
+  private transient long swigCPtr;
+  private transient boolean swigCMemOwn;
+
+  PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
+    swigCMemOwn = cMemoryOwn;
+    swigCPtr = cPtr;
+  }
+
+  CPTR_VISIBILITY static long getCPtr($javaclassname obj) {
+    return (obj == null) ? 0 : obj.swigCPtr;
+  }
+%}
+
+// Derived proxy classes
+%typemap(javabody_derived) TYPE %{
+  private transient long swigCPtr;
+  private transient boolean swigCMemOwnDerived;
+
+  PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
+    super($imclassname.$javaclazznameSWIGSmartPtrUpcast(cPtr), true);
+    swigCMemOwnDerived = cMemoryOwn;
+    swigCPtr = cPtr;
+  }
+
+  CPTR_VISIBILITY static long getCPtr($javaclassname obj) {
+    return (obj == null) ? 0 : obj.swigCPtr;
+  }
+%}
+
+%typemap(javadestruct, methodname="delete", methodmodifiers="public synchronized") TYPE {
+    if (swigCPtr != 0) {
+      if (swigCMemOwn) {
+        swigCMemOwn = false;
+        $jnicall;
+      }
+      swigCPtr = 0;
+    }
+  }
+
+%typemap(javadestruct_derived, methodname="delete", methodmodifiers="public synchronized") TYPE {
+    if (swigCPtr != 0) {
+      if (swigCMemOwnDerived) {
+        swigCMemOwnDerived = false;
+        $jnicall;
+      }
+      swigCPtr = 0;
+    }
+    super.delete();
+  }
+
+
+%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
+%enddef
+
diff --git a/share/swig/3.0.12/java/director.swg b/share/swig/3.0.12/java/director.swg
new file mode 100644
index 0000000..355e62d
--- /dev/null
+++ b/share/swig/3.0.12/java/director.swg
@@ -0,0 +1,413 @@
+/* -----------------------------------------------------------------------------
+ * director.swg
+ *
+ * This file contains support for director classes so that Java proxy
+ * methods can be called from C++.
+ * ----------------------------------------------------------------------------- */
+
+#if defined(DEBUG_DIRECTOR_OWNED) || defined(DEBUG_DIRECTOR_EXCEPTION)
+#include <iostream>
+#endif
+
+#include <exception>
+
+namespace Swig {
+
+  /* Java object wrapper */
+  class JObjectWrapper {
+  public:
+    JObjectWrapper() : jthis_(NULL), weak_global_(true) {
+    }
+
+    ~JObjectWrapper() {
+      jthis_ = NULL;
+      weak_global_ = true;
+    }
+
+    bool set(JNIEnv *jenv, jobject jobj, bool mem_own, bool weak_global) {
+      if (!jthis_) {
+        weak_global_ = weak_global || !mem_own; // hold as weak global if explicitly requested or not owned
+        if (jobj)
+          jthis_ = weak_global_ ? jenv->NewWeakGlobalRef(jobj) : jenv->NewGlobalRef(jobj);
+#if defined(DEBUG_DIRECTOR_OWNED)
+        std::cout << "JObjectWrapper::set(" << jobj << ", " << (weak_global ? "weak_global" : "global_ref") << ") -> " << jthis_ << std::endl;
+#endif
+        return true;
+      } else {
+#if defined(DEBUG_DIRECTOR_OWNED)
+        std::cout << "JObjectWrapper::set(" << jobj << ", " << (weak_global ? "weak_global" : "global_ref") << ") -> already set" << std::endl;
+#endif
+        return false;
+      }
+    }
+
+    jobject get(JNIEnv *jenv) const {
+#if defined(DEBUG_DIRECTOR_OWNED)
+      std::cout << "JObjectWrapper::get(";
+      if (jthis_)
+        std::cout << jthis_;
+      else
+        std::cout << "null";
+      std::cout << ") -> return new local ref" << std::endl;
+#endif
+      return (jthis_ ? jenv->NewLocalRef(jthis_) : jthis_);
+    }
+
+    void release(JNIEnv *jenv) {
+#if defined(DEBUG_DIRECTOR_OWNED)
+      std::cout << "JObjectWrapper::release(" << jthis_ << "): " << (weak_global_ ? "weak global ref" : "global ref") << std::endl;
+#endif
+      if (jthis_) {
+        if (weak_global_) {
+          if (jenv->IsSameObject(jthis_, NULL) == JNI_FALSE)
+            jenv->DeleteWeakGlobalRef((jweak)jthis_);
+        } else
+          jenv->DeleteGlobalRef(jthis_);
+      }
+
+      jthis_ = NULL;
+      weak_global_ = true;
+    }
+
+    /* Only call peek if you know what you are doing wrt to weak/global references */
+    jobject peek() {
+      return jthis_;
+    }
+
+    /* Java proxy releases ownership of C++ object, C++ object is now
+       responsible for destruction (creates NewGlobalRef to pin Java proxy) */
+    void java_change_ownership(JNIEnv *jenv, jobject jself, bool take_or_release) {
+      if (take_or_release) {  /* Java takes ownership of C++ object's lifetime. */
+        if (!weak_global_) {
+          jenv->DeleteGlobalRef(jthis_);
+          jthis_ = jenv->NewWeakGlobalRef(jself);
+          weak_global_ = true;
+        }
+      } else {
+	/* Java releases ownership of C++ object's lifetime */
+        if (weak_global_) {
+          jenv->DeleteWeakGlobalRef((jweak)jthis_);
+          jthis_ = jenv->NewGlobalRef(jself);
+          weak_global_ = false;
+        }
+      }
+    }
+
+  private:
+    /* pointer to Java object */
+    jobject jthis_;
+    /* Local or global reference flag */
+    bool weak_global_;
+  };
+
+  /* Local JNI reference deleter */
+  class LocalRefGuard {
+    JNIEnv *jenv_;
+    jobject jobj_;
+
+    // non-copyable
+    LocalRefGuard(const LocalRefGuard &);
+    LocalRefGuard &operator=(const LocalRefGuard &);
+  public:
+    LocalRefGuard(JNIEnv *jenv, jobject jobj): jenv_(jenv), jobj_(jobj) {}
+    ~LocalRefGuard() {
+      if (jobj_)
+        jenv_->DeleteLocalRef(jobj_);
+    }
+  };
+
+  /* director base class */
+  class Director {
+    /* pointer to Java virtual machine */
+    JavaVM *swig_jvm_;
+
+  protected:
+#if defined (_MSC_VER) && (_MSC_VER<1300)
+    class JNIEnvWrapper;
+    friend class JNIEnvWrapper;
+#endif
+    /* Utility class for managing the JNI environment */
+    class JNIEnvWrapper {
+      const Director *director_;
+      JNIEnv *jenv_;
+      int env_status;
+    public:
+      JNIEnvWrapper(const Director *director) : director_(director), jenv_(0), env_status(0) {
+#if defined(__ANDROID__)
+        JNIEnv **jenv = &jenv_;
+#else
+        void **jenv = (void **)&jenv_;
+#endif
+        env_status = director_->swig_jvm_->GetEnv((void **)&jenv_, JNI_VERSION_1_2);
+#if defined(SWIG_JAVA_ATTACH_CURRENT_THREAD_AS_DAEMON)
+        // Attach a daemon thread to the JVM. Useful when the JVM should not wait for
+        // the thread to exit upon shutdown. Only for jdk-1.4 and later.
+        director_->swig_jvm_->AttachCurrentThreadAsDaemon(jenv, NULL);
+#else
+        director_->swig_jvm_->AttachCurrentThread(jenv, NULL);
+#endif
+      }
+      ~JNIEnvWrapper() {
+#if !defined(SWIG_JAVA_NO_DETACH_CURRENT_THREAD)
+        // Some JVMs, eg jdk-1.4.2 and lower on Solaris have a bug and crash with the DetachCurrentThread call.
+        // However, without this call, the JVM hangs on exit when the thread was not created by the JVM and creates a memory leak.
+        if (env_status == JNI_EDETACHED)
+          director_->swig_jvm_->DetachCurrentThread();
+#endif
+      }
+      JNIEnv *getJNIEnv() const {
+        return jenv_;
+      }
+    };
+
+    /* Java object wrapper */
+    JObjectWrapper swig_self_;
+
+    /* Disconnect director from Java object */
+    void swig_disconnect_director_self(const char *disconn_method) {
+      JNIEnvWrapper jnienv(this) ;
+      JNIEnv *jenv = jnienv.getJNIEnv() ;
+      jobject jobj = swig_self_.get(jenv);
+      LocalRefGuard ref_deleter(jenv, jobj);
+#if defined(DEBUG_DIRECTOR_OWNED)
+      std::cout << "Swig::Director::disconnect_director_self(" << jobj << ")" << std::endl;
+#endif
+      if (jobj && jenv->IsSameObject(jobj, NULL) == JNI_FALSE) {
+        jmethodID disconn_meth = jenv->GetMethodID(jenv->GetObjectClass(jobj), disconn_method, "()V");
+        if (disconn_meth) {
+#if defined(DEBUG_DIRECTOR_OWNED)
+          std::cout << "Swig::Director::disconnect_director_self upcall to " << disconn_method << std::endl;
+#endif
+          jenv->CallVoidMethod(jobj, disconn_meth);
+        }
+      }
+    }
+
+  public:
+    Director(JNIEnv *jenv) : swig_jvm_((JavaVM *) NULL), swig_self_() {
+      /* Acquire the Java VM pointer */
+      jenv->GetJavaVM(&swig_jvm_);
+    }
+
+    virtual ~Director() {
+      JNIEnvWrapper jnienv(this) ;
+      JNIEnv *jenv = jnienv.getJNIEnv() ;
+      swig_self_.release(jenv);
+    }
+
+    bool swig_set_self(JNIEnv *jenv, jobject jself, bool mem_own, bool weak_global) {
+      return swig_self_.set(jenv, jself, mem_own, weak_global);
+    }
+
+    jobject swig_get_self(JNIEnv *jenv) const {
+      return swig_self_.get(jenv);
+    }
+
+    // Change C++ object's ownership, relative to Java
+    void swig_java_change_ownership(JNIEnv *jenv, jobject jself, bool take_or_release) {
+      swig_self_.java_change_ownership(jenv, jself, take_or_release);
+    }
+  };
+
+  // Zero initialized bool array
+  template<size_t N> class BoolArray {
+    bool array_[N];
+  public:
+    BoolArray() {
+      memset(array_, 0, sizeof(array_));
+    }
+    bool& operator[](size_t n) {
+      return array_[n];
+    }
+    bool operator[](size_t n) const {
+      return array_[n];
+    }
+  };
+
+  // Utility classes and functions for exception handling.
+
+  // Simple holder for a Java string during exception handling, providing access to a c-style string
+  class JavaString {
+  public:
+    JavaString(JNIEnv *jenv, jstring jstr) : jenv_(jenv), jstr_(jstr), cstr_(0) {
+      if (jenv_ && jstr_)
+	cstr_ = (const char *) jenv_->GetStringUTFChars(jstr_, NULL);
+    }
+
+    ~JavaString() {
+      if (jenv_ && jstr_ && cstr_)
+	jenv_->ReleaseStringUTFChars(jstr_, cstr_);
+    }
+
+    const char *c_str(const char *null_string = "null JavaString") const {
+      return cstr_ ? cstr_ : null_string;
+    }
+
+  private:
+    // non-copyable
+    JavaString(const JavaString &);
+    JavaString &operator=(const JavaString &);
+
+    JNIEnv *jenv_;
+    jstring jstr_;
+    const char *cstr_;
+  };
+
+  // Helper class to extract the exception message from a Java throwable
+  class JavaExceptionMessage {
+  public:
+    JavaExceptionMessage(JNIEnv *jenv, jthrowable throwable) : message_(jenv, exceptionMessageFromThrowable(jenv, throwable)) {
+    }
+
+    const char *message() const {
+      return message_.c_str("Could not get exception message in JavaExceptionMessage");
+    }
+
+  private:
+    // non-copyable
+    JavaExceptionMessage(const JavaExceptionMessage &);
+    JavaExceptionMessage &operator=(const JavaExceptionMessage &);
+
+    // Get exception message by calling Java method Throwable.getMessage()
+    static jstring exceptionMessageFromThrowable(JNIEnv *jenv, jthrowable throwable) {
+      jstring jmsg = NULL;
+      if (jenv && throwable) {
+	jenv->ExceptionClear(); // Cannot invoke methods with any pending exceptions
+	jclass throwclz = jenv->GetObjectClass(throwable);
+	if (throwclz) {
+	  // All Throwable classes have a getMessage() method, so call it to extract the exception message
+	  jmethodID getMessageMethodID = jenv->GetMethodID(throwclz, "getMessage", "()Ljava/lang/String;");
+	  if (getMessageMethodID)
+	    jmsg = (jstring)jenv->CallObjectMethod(throwable, getMessageMethodID);
+	}
+	if (jmsg == NULL && jenv->ExceptionCheck())
+	  jenv->ExceptionClear();
+      }
+      return jmsg;
+    }
+
+    JavaString message_;
+  };
+
+  // C++ Exception class for handling Java exceptions thrown during a director method Java upcall
+  class DirectorException : public std::exception {
+  public:
+
+    // Construct exception from a Java throwable
+    DirectorException(JNIEnv *jenv, jthrowable throwable) : classname_(0), msg_(0) {
+
+      // Call Java method Object.getClass().getName() to obtain the throwable's class name (delimited by '/')
+      if (throwable) {
+	jclass throwclz = jenv->GetObjectClass(throwable);
+	if (throwclz) {
+	  jclass clzclz = jenv->GetObjectClass(throwclz);
+	  if (clzclz) {
+	    jmethodID getNameMethodID = jenv->GetMethodID(clzclz, "getName", "()Ljava/lang/String;");
+	    if (getNameMethodID) {
+	      jstring jstr_classname = (jstring)(jenv->CallObjectMethod(throwclz, getNameMethodID));
+              // Copy strings, since there is no guarantee that jenv will be active when handled
+              if (jstr_classname) {
+                JavaString jsclassname(jenv, jstr_classname);
+                const char *classname = jsclassname.c_str(0);
+                if (classname)
+                  classname_ = copypath(classname);
+              }
+	    }
+	  }
+	}
+      }
+
+      JavaExceptionMessage exceptionmsg(jenv, throwable);
+      msg_ = copystr(exceptionmsg.message());
+    }
+
+    // More general constructor for handling as a java.lang.RuntimeException
+    DirectorException(const char *msg) : classname_(0), msg_(copystr(msg ? msg : "Unspecified DirectorException message")) {
+    }
+
+    ~DirectorException() throw() {
+      delete[] classname_;
+      delete[] msg_;
+    }
+
+    const char *what() const throw() {
+      return msg_;
+    }
+
+    // Reconstruct and raise/throw the Java Exception that caused the DirectorException
+    // Note that any error in the JNI exception handling results in a Java RuntimeException
+    void raiseJavaException(JNIEnv *jenv) const {
+      if (jenv) {
+	jenv->ExceptionClear();
+
+	jmethodID ctorMethodID = 0;
+	jclass throwableclass = 0;
+        if (classname_) {
+          throwableclass = jenv->FindClass(classname_);
+          if (throwableclass)
+            ctorMethodID = jenv->GetMethodID(throwableclass, "<init>", "(Ljava/lang/String;)V");
+	}
+
+	if (ctorMethodID) {
+	  jenv->ThrowNew(throwableclass, what());
+	} else {
+	  SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, what());
+	}
+      }
+    }
+
+  private:
+    static char *copypath(const char *srcmsg) {
+      char *target = copystr(srcmsg);
+      for (char *c=target; *c; ++c) {
+        if ('.' == *c)
+          *c = '/';
+      }
+      return target;
+    }
+
+    static char *copystr(const char *srcmsg) {
+      char *target = 0;
+      if (srcmsg) {
+	size_t msglen = strlen(srcmsg) + 1;
+	target = new char[msglen];
+	strncpy(target, srcmsg, msglen);
+      }
+      return target;
+    }
+
+    const char *classname_;
+    const char *msg_;
+  };
+
+  // Helper method to determine if a Java throwable matches a particular Java class type
+  SWIGINTERN bool ExceptionMatches(JNIEnv *jenv, jthrowable throwable, const char *classname) {
+    bool matches = false;
+
+    if (throwable && jenv && classname) {
+      // Exceptions need to be cleared for correct behavior.
+      // The caller of ExceptionMatches should restore pending exceptions if desired -
+      // the caller already has the throwable.
+      jenv->ExceptionClear();
+
+      jclass clz = jenv->FindClass(classname);
+      if (clz) {
+	jclass classclz = jenv->GetObjectClass(clz);
+	jmethodID isInstanceMethodID = jenv->GetMethodID(classclz, "isInstance", "(Ljava/lang/Object;)Z");
+	if (isInstanceMethodID) {
+	  matches = jenv->CallBooleanMethod(clz, isInstanceMethodID, throwable) != 0;
+	}
+      }
+
+#if defined(DEBUG_DIRECTOR_EXCEPTION)
+      if (jenv->ExceptionCheck()) {
+        // Typically occurs when an invalid classname argument is passed resulting in a ClassNotFoundException
+        JavaExceptionMessage exc(jenv, jenv->ExceptionOccurred());
+        std::cout << "Error: ExceptionMatches: class '" << classname << "' : " << exc.message() << std::endl;
+      }
+#endif
+    }
+    return matches;
+  }
+}
+
diff --git a/share/swig/3.0.12/java/enums.swg b/share/swig/3.0.12/java/enums.swg
new file mode 100644
index 0000000..81fe578
--- /dev/null
+++ b/share/swig/3.0.12/java/enums.swg
@@ -0,0 +1,116 @@
+/* -----------------------------------------------------------------------------
+ * enums.swg
+ *
+ * Include this file in order for C/C++ enums to be wrapped by proper Java enums.
+ * Note that the JNI layer handles the enum as an int. The Java enum has extra
+ * code generated to store the C++ int value. This is required for C++ enums that
+ * specify a value for the enum item, as native Java enums do not support this.
+ * ----------------------------------------------------------------------------- */
+
+// const enum SWIGTYPE & typemaps
+%typemap(jni) const enum SWIGTYPE & "jint"
+%typemap(jtype) const enum SWIGTYPE & "int"
+%typemap(jstype) const enum SWIGTYPE & "$*javaclassname"
+
+%typemap(in) const enum SWIGTYPE & ($*1_ltype temp)
+%{ temp = ($*1_ltype)$input; 
+   $1 = &temp; %}
+%typemap(out) const enum SWIGTYPE &  %{ $result = (jint)*$1; %}
+
+%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const enum SWIGTYPE &
+%{ static $*1_ltype temp = ($*1_ltype)$input; 
+   $result = &temp; %}
+%typemap(directorin, descriptor="L$packagepath/$*javaclassname;") const enum SWIGTYPE & "$input = (jint)$1;"
+%typemap(javadirectorin) const enum SWIGTYPE & "$*javaclassname.swigToEnum($jniinput)"
+%typemap(javadirectorout) const enum SWIGTYPE & "($javacall).swigValue()"
+
+%typecheck(SWIG_TYPECHECK_POINTER) const enum SWIGTYPE & ""
+
+%typemap(throws) const enum SWIGTYPE &
+%{ (void)$1;
+   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown"); %}
+
+%typemap(javain) const enum SWIGTYPE & "$javainput.swigValue()"
+%typemap(javaout) const enum SWIGTYPE & {
+    return $*javaclassname.swigToEnum($jnicall);
+  }
+
+
+// enum SWIGTYPE typemaps
+%typemap(jni) enum SWIGTYPE "jint"
+%typemap(jtype) enum SWIGTYPE "int"
+%typemap(jstype) enum SWIGTYPE "$javaclassname"
+
+%typemap(in) enum SWIGTYPE  %{ $1 = ($1_ltype)$input; %}
+%typemap(out) enum SWIGTYPE  %{ $result = (jint)$1; %}
+
+%typemap(directorout) enum SWIGTYPE  %{ $result = ($1_ltype)$input; %}
+%typemap(directorin, descriptor="L$packagepath/$javaclassname;") enum SWIGTYPE "$input = (jint) $1;"
+%typemap(javadirectorin) enum SWIGTYPE "$javaclassname.swigToEnum($jniinput)"
+%typemap(javadirectorout) enum SWIGTYPE "($javacall).swigValue()"
+
+%typecheck(SWIG_TYPECHECK_POINTER) enum SWIGTYPE ""
+
+%typemap(throws) enum SWIGTYPE
+%{ (void)$1;
+   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown"); %}
+
+%typemap(javain) enum SWIGTYPE "$javainput.swigValue()"
+%typemap(javaout) enum SWIGTYPE {
+    return $javaclassname.swigToEnum($jnicall);
+  }
+
+%typemap(javaclassmodifiers) enum SWIGTYPE "public enum"
+%typemap(javabase)           enum SWIGTYPE ""
+%typemap(javacode)           enum SWIGTYPE ""
+%typemap(javaimports)        enum SWIGTYPE ""
+%typemap(javainterfaces)     enum SWIGTYPE ""
+
+/*
+ * SwigNext static inner class used instead of a static int as static fields cannot be accessed from enum initialisers.
+ * The swigToEnum method is used to find the Java 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.
+ */
+%typemap(javabody) enum SWIGTYPE %{
+  public final int swigValue() {
+    return swigValue;
+  }
+
+  public static $javaclassname swigToEnum(int swigValue) {
+    $javaclassname[] swigValues = $javaclassname.class.getEnumConstants();
+    if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue)
+      return swigValues[swigValue];
+    for ($javaclassname swigEnum : swigValues)
+      if (swigEnum.swigValue == swigValue)
+        return swigEnum;
+    throw new IllegalArgumentException("No enum " + $javaclassname.class + " with value " + swigValue);
+  }
+
+  @SuppressWarnings("unused")
+  private $javaclassname() {
+    this.swigValue = SwigNext.next++;
+  }
+
+  @SuppressWarnings("unused")
+  private $javaclassname(int swigValue) {
+    this.swigValue = swigValue;
+    SwigNext.next = swigValue+1;
+  }
+
+  @SuppressWarnings("unused")
+  private $javaclassname($javaclassname swigEnum) {
+    this.swigValue = swigEnum.swigValue;
+    SwigNext.next = this.swigValue+1;
+  }
+
+  private final int swigValue;
+
+  private static class SwigNext {
+    private static int next = 0;
+  }
+%}
+
+%javaenum(proper);
+
diff --git a/share/swig/2.0.11/java/enumsimple.swg b/share/swig/3.0.12/java/enumsimple.swg
index c270149..c270149 100644
--- a/share/swig/2.0.11/java/enumsimple.swg
+++ b/share/swig/3.0.12/java/enumsimple.swg
diff --git a/share/swig/3.0.12/java/enumtypesafe.swg b/share/swig/3.0.12/java/enumtypesafe.swg
new file mode 100644
index 0000000..c2012f5
--- /dev/null
+++ b/share/swig/3.0.12/java/enumtypesafe.swg
@@ -0,0 +1,117 @@
+/* -----------------------------------------------------------------------------
+ * 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 Java class named after the
+ * enum and each enum item is a static instance of this class.
+ * ----------------------------------------------------------------------------- */
+
+// const enum SWIGTYPE & typemaps
+%typemap(jni) const enum SWIGTYPE & "jint"
+%typemap(jtype) const enum SWIGTYPE & "int"
+%typemap(jstype) const enum SWIGTYPE & "$*javaclassname"
+
+%typemap(in) const enum SWIGTYPE & ($*1_ltype temp)
+%{ temp = ($*1_ltype)$input; 
+   $1 = &temp; %}
+%typemap(out) const enum SWIGTYPE &  %{ $result = (jint)*$1; %}
+
+%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const enum SWIGTYPE &
+%{ static $*1_ltype temp = ($*1_ltype)$input; 
+   $result = &temp; %}
+%typemap(directorin, descriptor="L$packagepath/$*javaclassname;") const enum SWIGTYPE & "$input = (jint)$1;"
+%typemap(javadirectorin) const enum SWIGTYPE & "$*javaclassname.swigToEnum($jniinput)"
+%typemap(javadirectorout) const enum SWIGTYPE & "($javacall).swigValue()"
+
+%typecheck(SWIG_TYPECHECK_POINTER) const enum SWIGTYPE & ""
+
+%typemap(throws) const enum SWIGTYPE &
+%{ (void)$1;
+   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown"); %}
+
+%typemap(javain) const enum SWIGTYPE & "$javainput.swigValue()"
+%typemap(javaout) const enum SWIGTYPE & {
+    return $*javaclassname.swigToEnum($jnicall);
+  }
+
+// enum SWIGTYPE typemaps
+%typemap(jni) enum SWIGTYPE "jint"
+%typemap(jtype) enum SWIGTYPE "int"
+%typemap(jstype) enum SWIGTYPE "$javaclassname"
+
+%typemap(in) enum SWIGTYPE  %{ $1 = ($1_ltype)$input; %}
+%typemap(out) enum SWIGTYPE  %{ $result = (jint)$1; %}
+
+%typemap(directorout) enum SWIGTYPE  %{ $result = ($1_ltype)$input; %}
+%typemap(directorin, descriptor="L$packagepath/$javaclassname;") enum SWIGTYPE "$input = (jint) $1;"
+%typemap(javadirectorin) enum SWIGTYPE "$javaclassname.swigToEnum($jniinput)"
+%typemap(javadirectorout) enum SWIGTYPE "($javacall).swigValue()"
+
+%typecheck(SWIG_TYPECHECK_POINTER) enum SWIGTYPE ""
+
+%typemap(throws) enum SWIGTYPE
+%{ (void)$1;
+   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown"); %}
+
+%typemap(javain) enum SWIGTYPE "$javainput.swigValue()"
+%typemap(javaout) enum SWIGTYPE {
+    return $javaclassname.swigToEnum($jnicall);
+  }
+
+// '$static' will be replaced with either 'static' or nothing depending on whether the enum is an inner Java class or not
+%typemap(javaclassmodifiers) enum SWIGTYPE "public final $static class"
+%typemap(javabase)           enum SWIGTYPE ""
+%typemap(javacode)           enum SWIGTYPE ""
+%typemap(javaimports)        enum SWIGTYPE ""
+%typemap(javainterfaces)     enum SWIGTYPE ""
+
+/*
+ * The swigToEnum method is used to find the Java 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(javabody) enum SWIGTYPE %{
+  public final int swigValue() {
+    return swigValue;
+  }
+
+  public String toString() {
+    return swigName;
+  }
+
+  public static $javaclassname 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 IllegalArgumentException("No enum " + $javaclassname.class + " with value " + swigValue);
+  }
+
+  private $javaclassname(String swigName) {
+    this.swigName = swigName;
+    this.swigValue = swigNext++;
+  }
+
+  private $javaclassname(String swigName, int swigValue) {
+    this.swigName = swigName;
+    this.swigValue = swigValue;
+    swigNext = swigValue+1;
+  }
+
+  private $javaclassname(String swigName, $javaclassname swigEnum) {
+    this.swigName = swigName;
+    this.swigValue = swigEnum.swigValue;
+    swigNext = this.swigValue+1;
+  }
+
+  private static $javaclassname[] swigValues = { $enumvalues };
+  private static int swigNext = 0;
+  private final int swigValue;
+  private final String swigName;
+%}
+
+%javaenum(typesafe);
+
diff --git a/share/swig/2.0.11/java/enumtypeunsafe.swg b/share/swig/3.0.12/java/enumtypeunsafe.swg
index 31fb8a7..31fb8a7 100644
--- a/share/swig/2.0.11/java/enumtypeunsafe.swg
+++ b/share/swig/3.0.12/java/enumtypeunsafe.swg
diff --git a/share/swig/3.0.12/java/java.swg b/share/swig/3.0.12/java/java.swg
new file mode 100644
index 0000000..d173cb6
--- /dev/null
+++ b/share/swig/3.0.12/java/java.swg
@@ -0,0 +1,1379 @@
+/* -----------------------------------------------------------------------------
+ * java.swg
+ *
+ * Java typemaps
+ * ----------------------------------------------------------------------------- */
+
+%include <javahead.swg>
+
+/* The jni, jtype and jstype typemaps work together and so there should be one of each. 
+ * The jni typemap contains the JNI type used in the JNI (C/C++) code. 
+ * The jtype typemap contains the Java type used in the JNI intermediary class. 
+ * The jstype typemap contains the Java type used in the Java 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";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    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) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    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(jni) bool,               const bool &               "jboolean"
+%typemap(jni) char,               const char &               "jchar"
+%typemap(jni) signed char,        const signed char &        "jbyte"
+%typemap(jni) unsigned char,      const unsigned char &      "jshort"
+%typemap(jni) short,              const short &              "jshort"
+%typemap(jni) unsigned short,     const unsigned short &     "jint"
+%typemap(jni) int,                const int &                "jint"
+%typemap(jni) unsigned int,       const unsigned int &       "jlong"
+%typemap(jni) long,               const long &               "jint"
+%typemap(jni) unsigned long,      const unsigned long &      "jlong"
+%typemap(jni) long long,          const long long &          "jlong"
+%typemap(jni) unsigned long long, const unsigned long long & "jobject"
+%typemap(jni) float,              const float &              "jfloat"
+%typemap(jni) double,             const double &             "jdouble"
+%typemap(jni) void                                           "void"
+
+%typemap(jtype) bool,               const bool &               "boolean"
+%typemap(jtype) char,               const char &               "char"
+%typemap(jtype) signed char,        const signed char &        "byte"
+%typemap(jtype) unsigned char,      const unsigned char &      "short"
+%typemap(jtype) short,              const short &              "short"
+%typemap(jtype) unsigned short,     const unsigned short &     "int"
+%typemap(jtype) int,                const int &                "int"
+%typemap(jtype) unsigned int,       const unsigned int &       "long"
+%typemap(jtype) long,               const long &               "int"
+%typemap(jtype) unsigned long,      const unsigned long &      "long"
+%typemap(jtype) long long,          const long long &          "long"
+%typemap(jtype) unsigned long long, const unsigned long long & "java.math.BigInteger"
+%typemap(jtype) float,              const float &              "float"
+%typemap(jtype) double,             const double &             "double"
+%typemap(jtype) void                                           "void"
+
+%typemap(jstype) bool,               const bool &               "boolean"
+%typemap(jstype) char,               const char &               "char"
+%typemap(jstype) signed char,        const signed char &        "byte"
+%typemap(jstype) unsigned char,      const unsigned char &      "short"
+%typemap(jstype) short,              const short &              "short"
+%typemap(jstype) unsigned short,     const unsigned short &     "int"
+%typemap(jstype) int,                const int &                "int"
+%typemap(jstype) unsigned int,       const unsigned int &       "long"
+%typemap(jstype) long,               const long &               "int"
+%typemap(jstype) unsigned long,      const unsigned long &      "long"
+%typemap(jstype) long long,          const long long &          "long"
+%typemap(jstype) unsigned long long, const unsigned long long & "java.math.BigInteger"
+%typemap(jstype) float,              const float &              "float"
+%typemap(jstype) double,             const double &             "double"
+%typemap(jstype) void                                           "void"
+
+%typemap(jni) char *, char *&, char[ANY], char[]               "jstring"
+%typemap(jtype) char *, char *&, char[ANY], char[]               "String"
+%typemap(jstype) char *, char *&, char[ANY], char[]               "String"
+
+/* JNI types */
+%typemap(jni) jboolean      "jboolean"
+%typemap(jni) jchar         "jchar"
+%typemap(jni) jbyte         "jbyte"
+%typemap(jni) jshort        "jshort"
+%typemap(jni) jint          "jint"
+%typemap(jni) jlong         "jlong"
+%typemap(jni) jfloat        "jfloat"
+%typemap(jni) jdouble       "jdouble"
+%typemap(jni) jstring       "jstring"
+%typemap(jni) jobject       "jobject"
+%typemap(jni) jbooleanArray "jbooleanArray"
+%typemap(jni) jcharArray    "jcharArray"
+%typemap(jni) jbyteArray    "jbyteArray"
+%typemap(jni) jshortArray   "jshortArray"
+%typemap(jni) jintArray     "jintArray"
+%typemap(jni) jlongArray    "jlongArray"
+%typemap(jni) jfloatArray   "jfloatArray"
+%typemap(jni) jdoubleArray  "jdoubleArray"
+%typemap(jni) jobjectArray  "jobjectArray"
+
+%typemap(jtype) jboolean      "boolean"
+%typemap(jtype) jchar         "char"
+%typemap(jtype) jbyte         "byte"
+%typemap(jtype) jshort        "short"
+%typemap(jtype) jint          "int"
+%typemap(jtype) jlong         "long"
+%typemap(jtype) jfloat        "float"
+%typemap(jtype) jdouble       "double"
+%typemap(jtype) jstring       "String"
+%typemap(jtype) jobject       "Object"
+%typemap(jtype) jbooleanArray "boolean[]"
+%typemap(jtype) jcharArray    "char[]"
+%typemap(jtype) jbyteArray    "byte[]"
+%typemap(jtype) jshortArray   "short[]"
+%typemap(jtype) jintArray     "int[]"
+%typemap(jtype) jlongArray    "long[]"
+%typemap(jtype) jfloatArray   "float[]"
+%typemap(jtype) jdoubleArray  "double[]"
+%typemap(jtype) jobjectArray  "Object[]"
+
+%typemap(jstype) jboolean      "boolean"
+%typemap(jstype) jchar         "char"
+%typemap(jstype) jbyte         "byte"
+%typemap(jstype) jshort        "short"
+%typemap(jstype) jint          "int"
+%typemap(jstype) jlong         "long"
+%typemap(jstype) jfloat        "float"
+%typemap(jstype) jdouble       "double"
+%typemap(jstype) jstring       "String"
+%typemap(jstype) jobject       "Object"
+%typemap(jstype) jbooleanArray "boolean[]"
+%typemap(jstype) jcharArray    "char[]"
+%typemap(jstype) jbyteArray    "byte[]"
+%typemap(jstype) jshortArray   "short[]"
+%typemap(jstype) jintArray     "int[]"
+%typemap(jstype) jlongArray    "long[]"
+%typemap(jstype) jfloatArray   "float[]"
+%typemap(jstype) jdoubleArray  "double[]"
+%typemap(jstype) jobjectArray  "Object[]"
+
+/* Non primitive types */
+%typemap(jni) SWIGTYPE "jlong"
+%typemap(jtype) SWIGTYPE "long"
+%typemap(jstype) SWIGTYPE "$&javaclassname"
+
+%typemap(jni) SWIGTYPE [] "jlong"
+%typemap(jtype) SWIGTYPE [] "long"
+%typemap(jstype) SWIGTYPE [] "$javaclassname"
+
+%typemap(jni) SWIGTYPE * "jlong"
+%typemap(jtype) SWIGTYPE * "long"
+%typemap(jstype) SWIGTYPE * "$javaclassname"
+
+%typemap(jni) SWIGTYPE & "jlong"
+%typemap(jtype) SWIGTYPE & "long"
+%typemap(jstype) SWIGTYPE & "$javaclassname"
+
+%typemap(jni) SWIGTYPE && "jlong"
+%typemap(jtype) SWIGTYPE && "long"
+%typemap(jstype) SWIGTYPE && "$javaclassname"
+
+/* pointer to a class member */
+%typemap(jni) SWIGTYPE (CLASS::*) "jstring"
+%typemap(jtype) SWIGTYPE (CLASS::*) "String"
+%typemap(jstype) SWIGTYPE (CLASS::*) "$javaclassname"
+
+/* The following are the in, out, freearg, argout typemaps. These are the JNI code generating typemaps for converting from Java to C and visa versa. */
+
+/* primitive types */
+%typemap(in) bool
+%{ $1 = $input ? true : false; %}
+
+%typemap(directorout) bool
+%{ $result = $input ? true : false; %}
+
+%typemap(javadirectorin) bool "$jniinput"
+%typemap(javadirectorout) bool "$javacall"
+
+%typemap(in) char, 
+             signed char, 
+             unsigned char, 
+             short, 
+             unsigned short, 
+             int, 
+             unsigned int, 
+             long, 
+             unsigned long, 
+             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, 
+             float, 
+             double
+%{ $result = ($1_ltype)$input; %}
+
+%typemap(directorin, descriptor="Z") bool             "$input = (jboolean) $1;"
+%typemap(directorin, descriptor="C") char             "$input = (jint) $1;"
+%typemap(directorin, descriptor="B") signed char      "$input = (jbyte) $1;"
+%typemap(directorin, descriptor="S") unsigned char    "$input = (jshort) $1;"
+%typemap(directorin, descriptor="S") short            "$input = (jshort) $1;"
+%typemap(directorin, descriptor="I") unsigned short   "$input = (jint) $1;"
+%typemap(directorin, descriptor="I") int              "$input = (jint) $1;"
+%typemap(directorin, descriptor="J") unsigned int     "$input = (jlong) $1;"
+%typemap(directorin, descriptor="I") long             "$input = (jint) $1;"
+%typemap(directorin, descriptor="J") unsigned long    "$input = (jlong) $1;"
+%typemap(directorin, descriptor="J") long long        "$input = (jlong) $1;"
+%typemap(directorin, descriptor="F") float            "$input = (jfloat) $1;"
+%typemap(directorin, descriptor="D") double           "$input = (jdouble) $1;"
+
+%typemap(javadirectorin) char, 
+                         signed char, 
+                         unsigned char, 
+                         short, 
+                         unsigned short, 
+                         int, 
+                         unsigned int, 
+                         long, 
+                         unsigned long, 
+                         long long, 
+                         float, 
+                         double
+  "$jniinput"
+
+%typemap(javadirectorout) char, 
+                          signed char, 
+                          unsigned char, 
+                          short, 
+                          unsigned short, 
+                          int, 
+                          unsigned int, 
+                          long, 
+                          unsigned long, 
+                          long long, 
+                          float, 
+                          double
+  "$javacall"
+
+%typemap(out) bool           %{ $result = (jboolean)$1; %}
+%typemap(out) char           %{ $result = (jchar)$1; %}
+%typemap(out) signed char    %{ $result = (jbyte)$1; %}
+%typemap(out) unsigned char  %{ $result = (jshort)$1; %}
+%typemap(out) short          %{ $result = (jshort)$1; %}
+%typemap(out) unsigned short %{ $result = (jint)$1; %}
+%typemap(out) int            %{ $result = (jint)$1; %}
+%typemap(out) unsigned int   %{ $result = (jlong)$1; %}
+%typemap(out) long           %{ $result = (jint)$1; %}
+%typemap(out) unsigned long  %{ $result = (jlong)$1; %}
+%typemap(out) long long      %{ $result = (jlong)$1; %}
+%typemap(out) float          %{ $result = (jfloat)$1; %}
+%typemap(out) double         %{ $result = (jdouble)$1; %}
+
+/* unsigned long long */
+/* Convert from BigInteger using the toByteArray member function */
+%typemap(in) unsigned long long { 
+  jclass clazz;
+  jmethodID mid;
+  jbyteArray ba;
+  jbyte* bae;
+  jsize sz;
+  int i;
+
+  if (!$input) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
+    return $null;
+  }
+  clazz = JCALL1(GetObjectClass, jenv, $input);
+  mid = JCALL3(GetMethodID, jenv, clazz, "toByteArray", "()[B");
+  ba = (jbyteArray)JCALL2(CallObjectMethod, jenv, $input, mid);
+  bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
+  sz = JCALL1(GetArrayLength, jenv, ba);
+  $1 = 0;
+  if (sz > 0) {
+    $1 = ($1_type)(signed char)bae[0];
+    for(i=1; i<sz; i++) {
+      $1 = ($1 << 8) | ($1_type)(unsigned char)bae[i];
+    }
+  }
+  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
+}
+
+%typemap(directorout) unsigned long long { 
+  jclass clazz;
+  jmethodID mid;
+  jbyteArray ba;
+  jbyte* bae;
+  jsize sz;
+  int i;
+
+  if (!$input) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
+    return $null;
+  }
+  clazz = JCALL1(GetObjectClass, jenv, $input);
+  mid = JCALL3(GetMethodID, jenv, clazz, "toByteArray", "()[B");
+  ba = (jbyteArray)JCALL2(CallObjectMethod, jenv, $input, mid);
+  bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
+  sz = JCALL1(GetArrayLength, jenv, ba);
+  $result = 0;
+  if (sz > 0) {
+    $result = ($1_type)(signed char)bae[0];
+    for(i=1; i<sz; i++) {
+      $result = ($result << 8) | ($1_type)(unsigned char)bae[i];
+    }
+  }
+  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
+}
+
+
+/* Convert to BigInteger - byte array holds number in 2's complement big endian format */
+%typemap(out) unsigned long long { 
+  jbyteArray ba = JCALL1(NewByteArray, jenv, 9);
+  jbyte* bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
+  jclass clazz = JCALL1(FindClass, jenv, "java/math/BigInteger");
+  jmethodID mid = JCALL3(GetMethodID, jenv, clazz, "<init>", "([B)V");
+  jobject bigint;
+  int i;
+
+  bae[0] = 0;
+  for(i=1; i<9; i++ ) {
+    bae[i] = (jbyte)($1>>8*(8-i));
+  }
+
+  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
+  bigint = JCALL3(NewObject, jenv, clazz, mid, ba);
+  JCALL1(DeleteLocalRef, jenv, ba);
+  $result = bigint;
+}
+
+/* Convert to BigInteger (see out typemap) */
+%typemap(directorin, descriptor="Ljava/math/BigInteger;", noblock=1) unsigned long long, const unsigned long long & {
+{
+  jbyteArray ba = JCALL1(NewByteArray, jenv, 9);
+  jbyte* bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
+  jclass clazz = JCALL1(FindClass, jenv, "java/math/BigInteger");
+  jmethodID mid = JCALL3(GetMethodID, jenv, clazz, "<init>", "([B)V");
+  jobject bigint;
+  int swig_i;
+
+  bae[0] = 0;
+  for(swig_i=1; swig_i<9; swig_i++ ) {
+    bae[swig_i] = (jbyte)($1>>8*(8-swig_i));
+  }
+
+  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
+  bigint = JCALL3(NewObject, jenv, clazz, mid, ba);
+  JCALL1(DeleteLocalRef, jenv, ba);
+  $input = bigint;
+}
+Swig::LocalRefGuard $1_refguard(jenv, $input); }
+
+%typemap(javadirectorin) unsigned long long "$jniinput"
+%typemap(javadirectorout) unsigned long long "$javacall"
+
+/* char * - treat as String */
+%typemap(in, noblock=1) char * {
+ $1 = 0;
+  if ($input) {
+    $1 = ($1_ltype)JCALL2(GetStringUTFChars, jenv, $input, 0);
+    if (!$1) return $null;
+  }
+}
+
+%typemap(directorout, noblock=1, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) char * {
+  $1 = 0;
+  if ($input) {
+    $result = ($1_ltype)JCALL2(GetStringUTFChars, jenv, $input, 0);
+    if (!$result) return $null;
+  }
+}
+
+%typemap(directorin, descriptor="Ljava/lang/String;", noblock=1) char * {
+  $input = 0;
+  if ($1) {
+    $input = JCALL1(NewStringUTF, jenv, (const char *)$1);
+    if (!$input) return $null;
+  }
+  Swig::LocalRefGuard $1_refguard(jenv, $input);
+}
+
+%typemap(freearg, noblock=1) char * { if ($1) JCALL2(ReleaseStringUTFChars, jenv, $input, (const char *)$1); }
+%typemap(out, noblock=1) char * { if ($1) $result = JCALL1(NewStringUTF, jenv, (const char *)$1); }
+%typemap(javadirectorin) char * "$jniinput"
+%typemap(javadirectorout) char * "$javacall"
+
+/* char *& - treat as String */
+%typemap(in, noblock=1) char *& ($*1_ltype temp = 0) {
+ $1 = 0;
+  if ($input) {
+    temp = ($*1_ltype)JCALL2(GetStringUTFChars, jenv, $input, 0);
+    if (!temp) return $null;
+  }
+  $1 = &temp;
+}
+%typemap(freearg, noblock=1) char *& { if ($1 && *$1) JCALL2(ReleaseStringUTFChars, jenv, $input, (const char *)*$1); }
+%typemap(out, noblock=1) char *& { if (*$1) $result = JCALL1(NewStringUTF, jenv, (const char *)*$1); }
+
+%typemap(out) void ""
+%typemap(javadirectorin) void "$jniinput"
+%typemap(javadirectorout) void "$javacall"
+%typemap(directorin, descriptor="V") void ""
+
+/* primitive types by 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(javadirectorin) const bool & "$jniinput"
+%typemap(javadirectorout) const bool & "$javacall"
+
+%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 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 float &,
+             const double &
+%{ static $*1_ltype temp;
+   temp = ($*1_ltype)$input; 
+   $result = &temp; %}
+
+%typemap(directorin, descriptor="Z") const bool &           "$input = (jboolean)$1;"
+%typemap(directorin, descriptor="C") const char &           "$input = (jchar)$1;"
+%typemap(directorin, descriptor="B") const signed char &    "$input = (jbyte)$1;"
+%typemap(directorin, descriptor="S") const unsigned char &  "$input = (jshort)$1;"
+%typemap(directorin, descriptor="S") const short &          "$input = (jshort)$1;"
+%typemap(directorin, descriptor="I") const unsigned short & "$input = (jint)$1;"
+%typemap(directorin, descriptor="I") const int &            "$input = (jint)$1;"
+%typemap(directorin, descriptor="J") const unsigned int &   "$input = (jlong)$1;"
+%typemap(directorin, descriptor="I") const long &           "$input = (jint)$1;"
+%typemap(directorin, descriptor="J") const unsigned long &  "$input = (jlong)$1;"
+%typemap(directorin, descriptor="J") const long long &      "$input = (jlong)$1;"
+%typemap(directorin, descriptor="F") const float &          "$input = (jfloat)$1;"
+%typemap(directorin, descriptor="D") const double &         "$input = (jdouble)$1;"
+
+%typemap(javadirectorin) 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 float & ($*1_ltype temp), 
+                         const double & ($*1_ltype temp)
+  "$jniinput"
+
+%typemap(javadirectorout) 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 float & ($*1_ltype temp), 
+                          const double & ($*1_ltype temp)
+  "$javacall"
+
+
+%typemap(out) const bool &           %{ $result = (jboolean)*$1; %}
+%typemap(out) const char &           %{ $result = (jchar)*$1; %}
+%typemap(out) const signed char &    %{ $result = (jbyte)*$1; %}
+%typemap(out) const unsigned char &  %{ $result = (jshort)*$1; %}
+%typemap(out) const short &          %{ $result = (jshort)*$1; %}
+%typemap(out) const unsigned short & %{ $result = (jint)*$1; %}
+%typemap(out) const int &            %{ $result = (jint)*$1; %}
+%typemap(out) const unsigned int &   %{ $result = (jlong)*$1; %}
+%typemap(out) const long &           %{ $result = (jint)*$1; %}
+%typemap(out) const unsigned long &  %{ $result = (jlong)*$1; %}
+%typemap(out) const long long &      %{ $result = (jlong)*$1; %}
+%typemap(out) const float &          %{ $result = (jfloat)*$1; %}
+%typemap(out) const double &         %{ $result = (jdouble)*$1; %}
+
+/* const unsigned long long & */
+/* Similar to unsigned long long */
+%typemap(in) const unsigned long long & ($*1_ltype temp) { 
+  jclass clazz;
+  jmethodID mid;
+  jbyteArray ba;
+  jbyte* bae;
+  jsize sz;
+  int i;
+
+  if (!$input) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
+    return $null;
+  }
+  clazz = JCALL1(GetObjectClass, jenv, $input);
+  mid = JCALL3(GetMethodID, jenv, clazz, "toByteArray", "()[B");
+  ba = (jbyteArray)JCALL2(CallObjectMethod, jenv, $input, mid);
+  bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
+  sz = JCALL1(GetArrayLength, jenv, ba);
+  $1 = &temp;
+  temp = 0;
+  if (sz > 0) {
+    temp = ($*1_ltype)(signed char)bae[0];
+    for(i=1; i<sz; i++) {
+      temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
+    }
+  }
+  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
+}
+
+%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const unsigned long long & { 
+  static $*1_ltype temp;
+  jclass clazz;
+  jmethodID mid;
+  jbyteArray ba;
+  jbyte* bae;
+  jsize sz;
+  int i;
+
+  if (!$input) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
+    return $null;
+  }
+  clazz = JCALL1(GetObjectClass, jenv, $input);
+  mid = JCALL3(GetMethodID, jenv, clazz, "toByteArray", "()[B");
+  ba = (jbyteArray)JCALL2(CallObjectMethod, jenv, $input, mid);
+  bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
+  sz = JCALL1(GetArrayLength, jenv, ba);
+  $result = &temp;
+  temp = 0;
+  if (sz > 0) {
+    temp = ($*1_ltype)(signed char)bae[0];
+    for(i=1; i<sz; i++) {
+      temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
+    }
+  }
+  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
+}
+
+%typemap(out) const unsigned long long & { 
+  jbyteArray ba = JCALL1(NewByteArray, jenv, 9);
+  jbyte* bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
+  jclass clazz = JCALL1(FindClass, jenv, "java/math/BigInteger");
+  jmethodID mid = JCALL3(GetMethodID, jenv, clazz, "<init>", "([B)V");
+  jobject bigint;
+  int i;
+
+  bae[0] = 0;
+  for(i=1; i<9; i++ ) {
+    bae[i] = (jbyte)(*$1>>8*(8-i));
+  }
+
+  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
+  bigint = JCALL3(NewObject, jenv, clazz, mid, ba);
+  JCALL1(DeleteLocalRef, jenv, ba);
+  $result = bigint;
+}
+
+%typemap(javadirectorin) const unsigned long long & "$jniinput"
+%typemap(javadirectorout) const unsigned long long & "$javacall"
+
+/* Default handling. Object passed by value. Convert to a pointer */
+%typemap(in) SWIGTYPE ($&1_type argp)
+%{ argp = *($&1_ltype*)&$input; 
+   if (!argp) {
+     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null $1_type");
+     return $null;
+   }
+   $1 = *argp; %}
+
+%typemap(directorout) SWIGTYPE ($&1_type argp)
+%{ argp = *($&1_ltype*)&$input; 
+   if (!argp) {
+     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Unexpected null return for type $1_type");
+     return $null;
+   }
+   $result = *argp; %}
+
+%typemap(out) SWIGTYPE 
+#ifdef __cplusplus
+%{ *($&1_ltype*)&$result = new $1_ltype((const $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,descriptor="L$packagepath/$&javaclassname;") SWIGTYPE 
+%{ $input = 0;
+   *(($&1_ltype*)&$input) = new $1_ltype((const $1_ltype &)$1); %}
+%typemap(javadirectorin) SWIGTYPE "new $&javaclassname($jniinput, true)"
+%typemap(javadirectorout) SWIGTYPE "$&javaclassname.getCPtr($javacall)"
+
+/* Generic pointers and references */
+%typemap(in) SWIGTYPE * %{ $1 = *($&1_ltype)&$input; %}
+%typemap(in, fragment="SWIG_UnPackData") SWIGTYPE (CLASS::*) { 
+  const char *temp = 0;
+  if ($input) {
+    temp = JCALL2(GetStringUTFChars, jenv, $input, 0);
+    if (!temp) return $null;
+  }
+  SWIG_UnpackData(temp, (void *)&$1, sizeof($1));
+}
+%typemap(in) SWIGTYPE & %{ $1 = *($&1_ltype)&$input;
+  if (!$1) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null");
+    return $null;
+  } %}
+%typemap(in) SWIGTYPE && %{ $1 = *($&1_ltype)&$input;
+  if (!$1) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null");
+    return $null;
+  } %}
+%typemap(out) SWIGTYPE *
+%{ *($&1_ltype)&$result = $1; %} 
+%typemap(out, fragment="SWIG_PackData", noblock=1) SWIGTYPE (CLASS::*) {
+  char buf[128];
+  char *data = SWIG_PackData(buf, (void *)&$1, sizeof($1));
+  *data = '\0';
+  $result = JCALL1(NewStringUTF, jenv, buf);
+}
+%typemap(out) SWIGTYPE &
+%{ *($&1_ltype)&$result = $1; %} 
+%typemap(out) SWIGTYPE &&
+%{ *($&1_ltype)&$result = $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,descriptor="L$packagepath/$javaclassname;") SWIGTYPE *
+%{ *(($&1_ltype)&$input) = ($1_ltype) $1; %}
+%typemap(directorin,descriptor="L$packagepath/$javaclassname;") SWIGTYPE (CLASS::*)
+%{ *(($&1_ltype)&$input) = ($1_ltype) $1; %}
+
+%typemap(directorout, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) SWIGTYPE &
+%{ if (!$input) {
+     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Unexpected null return for type $1_type");
+     return $null;
+   }
+   $result = *($&1_ltype)&$input; %}
+%typemap(directorout, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) SWIGTYPE &&
+%{ if (!$input) {
+     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Unexpected null return for type $1_type");
+     return $null;
+   }
+   $result = *($&1_ltype)&$input; %}
+%typemap(directorin,descriptor="L$packagepath/$javaclassname;") SWIGTYPE &
+%{ *($&1_ltype)&$input = ($1_ltype) &$1; %}
+%typemap(directorin,descriptor="L$packagepath/$javaclassname;") SWIGTYPE &&
+%{ *($&1_ltype)&$input = ($1_ltype) &$1; %}
+
+%typemap(javadirectorin) SWIGTYPE *, SWIGTYPE (CLASS::*) "($jniinput == 0) ? null : new $javaclassname($jniinput, false)"
+%typemap(javadirectorin) SWIGTYPE & "new $javaclassname($jniinput, false)"
+%typemap(javadirectorin) SWIGTYPE && "new $javaclassname($jniinput, false)"
+%typemap(javadirectorout) SWIGTYPE *, SWIGTYPE (CLASS::*), SWIGTYPE &, SWIGTYPE && "$javaclassname.getCPtr($javacall)"
+
+/* Default array handling */
+%typemap(in) SWIGTYPE [] %{ $1 = *($&1_ltype)&$input; %}
+%typemap(out) SWIGTYPE [] %{ *($&1_ltype)&$result = $1; %} 
+%typemap(freearg) SWIGTYPE [ANY], SWIGTYPE [] ""
+
+/* char arrays - treat as String */
+%typemap(in, noblock=1) char[ANY], char[] {
+  $1 = 0;
+  if ($input) {
+    $1 = ($1_ltype)JCALL2(GetStringUTFChars, jenv, $input, 0);
+    if (!$1) return $null;
+  }
+}
+
+%typemap(directorout, noblock=1) char[ANY], char[] {
+  $1 = 0;
+  if ($input) {
+    $result = ($1_ltype)JCALL2(GetStringUTFChars, jenv, $input, 0);
+    if (!$result) return $null;
+  }
+}
+
+%typemap(directorin, descriptor="Ljava/lang/String;", noblock=1) char[ANY], char[] {
+  $input = 0;
+  if ($1) {
+    $input = JCALL1(NewStringUTF, jenv, (const char *)$1);
+    if (!$input) return $null;
+  }
+  Swig::LocalRefGuard $1_refguard(jenv, $input);
+}
+
+%typemap(argout) char[ANY], char[] ""
+%typemap(freearg, noblock=1) char[ANY], char[] { if ($1) JCALL2(ReleaseStringUTFChars, jenv, $input, (const char *)$1); }
+%typemap(out, noblock=1) char[ANY], char[] { if ($1) $result = JCALL1(NewStringUTF, jenv, (const char *)$1); }
+%typemap(javadirectorin) char[ANY], char[] "$jniinput"
+%typemap(javadirectorout) char[ANY], char[] "$javacall"
+
+/* JNI types */
+%typemap(in) jboolean,
+             jchar,
+             jbyte,
+             jshort,
+             jint,
+             jlong,
+             jfloat,
+             jdouble,
+             jstring,
+             jobject,
+             jbooleanArray,
+             jcharArray,
+             jbyteArray,
+             jshortArray,
+             jintArray,
+             jlongArray,
+             jfloatArray,
+             jdoubleArray,
+             jobjectArray
+%{ $1 = $input; %}
+
+%typemap(directorout) jboolean,
+             jchar,
+             jbyte,
+             jshort,
+             jint,
+             jlong,
+             jfloat,
+             jdouble,
+             jstring,
+             jobject,
+             jbooleanArray,
+             jcharArray,
+             jbyteArray,
+             jshortArray,
+             jintArray,
+             jlongArray,
+             jfloatArray,
+             jdoubleArray,
+             jobjectArray
+%{ $result = $input; %}
+
+%typemap(out) jboolean,
+              jchar,
+              jbyte,
+              jshort,
+              jint,
+              jlong,
+              jfloat,
+              jdouble,
+              jstring,
+              jobject,
+              jbooleanArray,
+              jcharArray,
+              jbyteArray,
+              jshortArray,
+              jintArray,
+              jlongArray,
+              jfloatArray,
+              jdoubleArray,
+              jobjectArray
+%{ $result = $1; %}
+
+%typemap(directorin,descriptor="Z")  jboolean       "$input = $1;"
+%typemap(directorin,descriptor="C")  jchar          "$input = $1;"
+%typemap(directorin,descriptor="B")  jbyte          "$input = $1;"
+%typemap(directorin,descriptor="S")  jshort         "$input = $1;"
+%typemap(directorin,descriptor="I")  jint           "$input = $1;"
+%typemap(directorin,descriptor="J")  jlong          "$input = $1;"
+%typemap(directorin,descriptor="F")  jfloat         "$input = $1;"
+%typemap(directorin,descriptor="D")  jdouble        "$input = $1;"
+%typemap(directorin,descriptor="Ljava/lang/String;")            jstring        "$input = $1;"
+%typemap(directorin,descriptor="Ljava/lang/Object;",nouse="1")  jobject        "$input = $1;"
+%typemap(directorin,descriptor="[Z")  jbooleanArray "$input = $1;"
+%typemap(directorin,descriptor="[C")  jcharArray    "$input = $1;"
+%typemap(directorin,descriptor="[B")  jbyteArray    "$input = $1;"
+%typemap(directorin,descriptor="[S")  jshortArray   "$input = $1;"
+%typemap(directorin,descriptor="[I")  jintArray     "$input = $1;"
+%typemap(directorin,descriptor="[J")  jlongArray    "$input = $1;"
+%typemap(directorin,descriptor="[F")  jfloatArray   "$input = $1;"
+%typemap(directorin,descriptor="[D")  jdoubleArray  "$input = $1;"
+%typemap(directorin,descriptor="[Ljava/lang/Object;",nouse="1") jobjectArray   "$input = $1;"
+
+%typemap(javadirectorin) jboolean,
+                         jchar,
+                         jbyte,
+                         jshort,
+                         jint,
+                         jlong,
+                         jfloat,
+                         jdouble,
+                         jstring,
+                         jobject,
+                         jbooleanArray,
+                         jcharArray,
+                         jbyteArray,
+                         jshortArray,
+                         jintArray,
+                         jlongArray,
+                         jfloatArray,
+                         jdoubleArray,
+                         jobjectArray
+  "$jniinput"
+
+%typemap(javadirectorout) jboolean,
+                          jchar,
+                          jbyte,
+                          jshort,
+                          jint,
+                          jlong,
+                          jfloat,
+                          jdouble,
+                          jstring,
+                          jobject,
+                          jbooleanArray,
+                          jcharArray,
+                          jbyteArray,
+                          jshortArray,
+                          jintArray,
+                          jlongArray,
+                          jfloatArray,
+                          jdoubleArray,
+                          jobjectArray
+  "$javacall"
+
+/* Typecheck typemaps - The purpose of these is merely to issue a warning for overloaded C++ functions 
+ * that cannot be overloaded in Java as more than one C++ type maps to a single Java type */
+
+%typecheck(SWIG_TYPECHECK_BOOL) /* Java boolean */
+    jboolean,
+    bool,
+    const bool &
+    ""
+
+%typecheck(SWIG_TYPECHECK_CHAR) /* Java char */
+    jchar,
+    char, 
+    const char &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT8) /* Java byte */
+    jbyte,
+    signed char,
+    const signed char &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT16) /* Java short */
+    jshort,
+    unsigned char, 
+    short, 
+    const unsigned char &, 
+    const short &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT32) /* Java int */
+    jint,
+    unsigned short, 
+    int, 
+    long, 
+    const unsigned short &, 
+    const int &, 
+    const long &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT64) /* Java long */
+    jlong,
+    unsigned int, 
+    unsigned long, 
+    long long, 
+    const unsigned int &, 
+    const unsigned long &, 
+    const long long &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT128) /* Java BigInteger */
+    unsigned long long,
+    const unsigned long long &
+    ""
+
+%typecheck(SWIG_TYPECHECK_FLOAT) /* Java float */
+    jfloat,
+    float,
+    const float &
+    ""
+
+%typecheck(SWIG_TYPECHECK_DOUBLE) /* Java double */
+    jdouble,
+    double,
+    const double &
+    ""
+
+%typecheck(SWIG_TYPECHECK_STRING) /* Java String */
+    jstring,
+    char *,
+    char *&,
+    char[ANY],
+    char []
+    ""
+
+%typecheck(SWIG_TYPECHECK_BOOL_ARRAY) /* Java boolean[] */
+    jbooleanArray
+    ""
+
+%typecheck(SWIG_TYPECHECK_CHAR_ARRAY) /* Java char[] */
+    jcharArray
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT8_ARRAY) /* Java byte[] */
+    jbyteArray
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT16_ARRAY) /* Java short[] */
+    jshortArray
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT32_ARRAY) /* Java int[] */
+    jintArray
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT64_ARRAY) /* Java long[] */
+    jlongArray
+    ""
+
+%typecheck(SWIG_TYPECHECK_FLOAT_ARRAY) /* Java float[] */
+    jfloatArray
+    ""
+
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY) /* Java double[] */
+    jdoubleArray
+    ""
+
+%typecheck(SWIG_TYPECHECK_OBJECT_ARRAY) /* Java jobject[] */
+    jobjectArray
+    ""
+
+%typecheck(SWIG_TYPECHECK_POINTER) /* Default */
+    SWIGTYPE, 
+    SWIGTYPE *, 
+    SWIGTYPE &, 
+    SWIGTYPE &&, 
+    SWIGTYPE *const&, 
+    SWIGTYPE [],
+    SWIGTYPE (CLASS::*)
+    ""
+
+
+/* Exception handling */
+
+%typemap(throws) 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_JavaThrowException(jenv, SWIG_JavaRuntimeException, error_msg);
+   return $null; %}
+
+%typemap(throws) SWIGTYPE, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE *, SWIGTYPE [], SWIGTYPE [ANY]
+%{ (void)$1;
+   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown");
+   return $null; %}
+
+%typemap(throws) char *
+%{ SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1);
+   return $null; %}
+
+
+/* Typemaps for code generation in proxy classes and Java type wrapper classes */
+
+/* The javain 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 JNI class. */
+%typemap(javain) 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 &
+    "$javainput"
+%typemap(javain) char *, char *&, char[ANY], char[] "$javainput"
+%typemap(javain) jboolean,
+                 jchar,
+                 jbyte,
+                 jshort,
+                 jint,
+                 jlong,
+                 jfloat,
+                 jdouble,
+                 jstring,
+                 jobject,
+                 jbooleanArray,
+                 jcharArray,
+                 jbyteArray,
+                 jshortArray,
+                 jintArray,
+                 jlongArray,
+                 jfloatArray,
+                 jdoubleArray,
+                 jobjectArray
+    "$javainput"
+%typemap(javain) SWIGTYPE "$&javaclassname.getCPtr($javainput)"
+%typemap(javain) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] "$javaclassname.getCPtr($javainput)"
+%typemap(javain) SWIGTYPE (CLASS::*) "$javaclassname.getCMemberPtr($javainput)"
+
+/* The javaout typemap is used for converting function return types from the return type
+ * used in the JNI class to the type returned by the proxy, module or type wrapper class. */
+%typemap(javaout) 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 & {
+    return $jnicall;
+  }
+%typemap(javaout) char *, char *&, char[ANY], char[] {
+    return $jnicall;
+  }
+%typemap(javaout) jboolean,
+                  jchar,
+                  jbyte,
+                  jshort,
+                  jint,
+                  jlong,
+                  jfloat,
+                  jdouble,
+                  jstring,
+                  jobject,
+                  jbooleanArray,
+                  jcharArray,
+                  jbyteArray,
+                  jshortArray,
+                  jintArray,
+                  jlongArray,
+                  jfloatArray,
+                  jdoubleArray,
+                  jobjectArray {
+    return $jnicall;
+  }
+%typemap(javaout) void {
+    $jnicall;
+  }
+%typemap(javaout) SWIGTYPE {
+    return new $&javaclassname($jnicall, true);
+  }
+%typemap(javaout) SWIGTYPE & {
+    return new $javaclassname($jnicall, $owner);
+  }
+%typemap(javaout) SWIGTYPE && {
+    return new $javaclassname($jnicall, $owner);
+  }
+%typemap(javaout) SWIGTYPE *, SWIGTYPE [] {
+    long cPtr = $jnicall;
+    return (cPtr == 0) ? null : new $javaclassname(cPtr, $owner);
+  }
+%typemap(javaout) SWIGTYPE (CLASS::*) {
+    String cMemberPtr = $jnicall;
+    return (cMemberPtr == null) ? null : new $javaclassname(cMemberPtr, $owner);
+  }
+
+/* Pointer reference typemaps */
+%typemap(jni) SWIGTYPE *const& "jlong"
+%typemap(jtype) SWIGTYPE *const& "long"
+%typemap(jstype) SWIGTYPE *const& "$*javaclassname"
+%typemap(javain) SWIGTYPE *const& "$*javaclassname.getCPtr($javainput)"
+%typemap(javaout) SWIGTYPE *const& {
+    long cPtr = $jnicall;
+    return (cPtr == 0) ? null : new $*javaclassname(cPtr, $owner);
+  }
+%typemap(in) SWIGTYPE *const& ($*1_ltype temp = 0)
+%{ temp = *($1_ltype)&$input;
+   $1 = ($1_ltype)&temp; %}
+%typemap(out) SWIGTYPE *const&
+%{ *($1_ltype)&$result = *$1; %} 
+
+/* Typemaps used for the generation of proxy and type wrapper class code */
+%typemap(javabase)             SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+%typemap(javaclassmodifiers)   SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) "public class"
+%typemap(javacode)             SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+%typemap(javaimports)          SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+%typemap(javainterfaces)       SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+
+/* javabody typemaps */
+
+%define SWIG_JAVABODY_METHODS(PTRCTOR_VISIBILITY, CPTR_VISIBILITY, TYPE...) SWIG_JAVABODY_PROXY(PTRCTOR_VISIBILITY, CPTR_VISIBILITY, TYPE) %enddef // legacy name
+
+%define SWIG_JAVABODY_PROXY(PTRCTOR_VISIBILITY, CPTR_VISIBILITY, TYPE...)
+// Base proxy classes
+%typemap(javabody) TYPE %{
+  private transient long swigCPtr;
+  protected transient boolean swigCMemOwn;
+
+  PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
+    swigCMemOwn = cMemoryOwn;
+    swigCPtr = cPtr;
+  }
+
+  CPTR_VISIBILITY static long getCPtr($javaclassname obj) {
+    return (obj == null) ? 0 : obj.swigCPtr;
+  }
+%}
+
+// Derived proxy classes
+%typemap(javabody_derived) TYPE %{
+  private transient long swigCPtr;
+
+  PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
+    super($imclassname.$javaclazznameSWIGUpcast(cPtr), cMemoryOwn);
+    swigCPtr = cPtr;
+  }
+
+  CPTR_VISIBILITY static long getCPtr($javaclassname obj) {
+    return (obj == null) ? 0 : obj.swigCPtr;
+  }
+%}
+%enddef
+
+%define SWIG_JAVABODY_TYPEWRAPPER(PTRCTOR_VISIBILITY, DEFAULTCTOR_VISIBILITY, CPTR_VISIBILITY, TYPE...)
+// Typewrapper classes
+%typemap(javabody) TYPE *, TYPE &, TYPE &&, TYPE [] %{
+  private transient long swigCPtr;
+
+  PTRCTOR_VISIBILITY $javaclassname(long cPtr, @SuppressWarnings("unused") boolean futureUse) {
+    swigCPtr = cPtr;
+  }
+
+  DEFAULTCTOR_VISIBILITY $javaclassname() {
+    swigCPtr = 0;
+  }
+
+  CPTR_VISIBILITY static long getCPtr($javaclassname obj) {
+    return (obj == null) ? 0 : obj.swigCPtr;
+  }
+%}
+
+%typemap(javabody) TYPE (CLASS::*) %{
+  private transient String swigCMemberPtr;
+
+  PTRCTOR_VISIBILITY $javaclassname(String cMemberPtr, @SuppressWarnings("unused") boolean futureUse) {
+    swigCMemberPtr = cMemberPtr;
+  }
+
+  DEFAULTCTOR_VISIBILITY $javaclassname() {
+    swigCMemberPtr = null;
+  }
+
+  CPTR_VISIBILITY static String getCMemberPtr($javaclassname obj) {
+    return obj.swigCMemberPtr;
+  }
+%}
+%enddef
+
+/* Set the default javabody typemaps to use protected visibility.
+   Use the macros to change to public if using multiple modules. */
+SWIG_JAVABODY_PROXY(protected, protected, SWIGTYPE)
+SWIG_JAVABODY_TYPEWRAPPER(protected, protected, protected, SWIGTYPE)
+
+%typemap(javafinalize) SWIGTYPE %{
+  protected void finalize() {
+    delete();
+  }
+%}
+
+/*
+ * Java constructor typemaps:
+ *
+ * The javaconstruct typemap is inserted when a proxy class's constructor is generated.
+ * This typemap allows control over what code is executed in the constructor as
+ * well as specifying who owns the underlying C/C++ object. Normally, Java has
+ * ownership and the underlying C/C++ object is deallocated when the Java object
+ * is finalized (swigCMemOwn is true.) If swigCMemOwn is false, C/C++ is
+ * ultimately responsible for deallocating the underlying object's memory.
+ *
+ * The SWIG_PROXY_CONSTRUCTOR macro defines the javaconstruct typemap for a proxy
+ * class for a particular TYPENAME. OWNERSHIP is passed as the value of
+ * swigCMemOwn to the pointer constructor method.  WEAKREF determines which kind
+ * of Java object reference will be used by the C++ director class (WeakGlobalRef
+ * vs. GlobalRef.)
+ *
+ * The SWIG_DIRECTOR_OWNED macro sets the ownership of director-based proxy
+ * classes and the weak reference flag to false, meaning that the underlying C++
+ * object will be reclaimed by C++.
+ */
+
+%define SWIG_PROXY_CONSTRUCTOR(OWNERSHIP, WEAKREF, TYPENAME...)
+%typemap(javaconstruct,directorconnect="\n    $imclassname.$javaclazznamedirector_connect(this, swigCPtr, swigCMemOwn, WEAKREF);") TYPENAME {
+    this($imcall, OWNERSHIP);$directorconnect
+  }
+%enddef
+
+%define SWIG_DIRECTOR_OWNED(TYPENAME...)
+SWIG_PROXY_CONSTRUCTOR(true, false, TYPENAME)
+%enddef
+
+// Set the default for SWIGTYPE: Java owns the C/C++ object.
+SWIG_PROXY_CONSTRUCTOR(true, true, SWIGTYPE)
+
+%typemap(javadestruct, methodname="delete", methodmodifiers="public synchronized") SWIGTYPE {
+    if (swigCPtr != 0) {
+      if (swigCMemOwn) {
+        swigCMemOwn = false;
+        $jnicall;
+      }
+      swigCPtr = 0;
+    }
+  }
+
+%typemap(javadestruct_derived, methodname="delete", methodmodifiers="public synchronized") SWIGTYPE {
+    if (swigCPtr != 0) {
+      if (swigCMemOwn) {
+        swigCMemOwn = false;
+        $jnicall;
+      }
+      swigCPtr = 0;
+    }
+    super.delete();
+  }
+
+%typemap(directordisconnect, methodname="swigDirectorDisconnect") SWIGTYPE %{
+  protected void $methodname() {
+    swigCMemOwn = false;
+    $jnicall;
+  }
+%}
+
+%typemap(directorowner_release, methodname="swigReleaseOwnership") SWIGTYPE %{
+  public void $methodname() {
+    swigCMemOwn = false;
+    $jnicall;
+  }
+%}
+
+%typemap(directorowner_take, methodname="swigTakeOwnership") SWIGTYPE %{
+  public void $methodname() {
+    swigCMemOwn = true;
+    $jnicall;
+  }
+%}
+
+/* Java specific directives */
+#define %javaconst(flag)            %feature("java:const","flag")
+#define %javaconstvalue(value)      %feature("java:constvalue",value)
+#define %javaenum(wrapapproach)     %feature("java:enum","wrapapproach")
+#define %javamethodmodifiers        %feature("java:methodmodifiers")
+#define %javaexception(exceptionclasses) %feature("except",throws=exceptionclasses)
+#define %nojavaexception            %feature("except","0",throws="")
+#define %clearjavaexception         %feature("except","",throws="")
+#define %proxycode                  %insert("proxycode")
+
+%pragma(java) jniclassclassmodifiers="public class"
+%pragma(java) moduleclassmodifiers="public class"
+
+/* Some ANSI C typemaps */
+
+%apply unsigned long { size_t };
+%apply const unsigned long & { const size_t & };
+
+/* Array reference typemaps */
+%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) }
+
+/* const pointers */
+%apply SWIGTYPE * { SWIGTYPE *const }
+
+/* String & length */
+%typemap(jni)     (char *STRING, size_t LENGTH) "jbyteArray"
+%typemap(jtype)   (char *STRING, size_t LENGTH) "byte[]"
+%typemap(jstype)  (char *STRING, size_t LENGTH) "byte[]"
+%typemap(javain)  (char *STRING, size_t LENGTH) "$javainput"
+%typemap(freearg) (char *STRING, size_t LENGTH) ""
+%typemap(in)      (char *STRING, size_t LENGTH) {
+  if ($input) {
+    $1 = ($1_ltype) JCALL2(GetByteArrayElements, jenv, $input, 0);
+    $2 = ($2_type) JCALL1(GetArrayLength, jenv, $input);
+  } else {
+    $1 = 0;
+    $2 = 0;
+  }
+}
+%typemap(argout)  (char *STRING, size_t LENGTH) {
+  if ($input) JCALL3(ReleaseByteArrayElements, jenv, $input, (jbyte *)$1, 0);
+}
+%typemap(directorin, descriptor="[B", noblock=1) (char *STRING, size_t LENGTH) {
+  $input = 0;
+  if ($1) {
+    $input = JCALL1(NewByteArray, jenv, (jsize)$2);
+    if (!$input) return $null;
+    JCALL4(SetByteArrayRegion, jenv, $input, 0, (jsize)$2, (jbyte *)$1);
+  }
+  Swig::LocalRefGuard $1_refguard(jenv, $input);
+}
+%typemap(directorargout, noblock=1) (char *STRING, size_t LENGTH)
+{ if ($input && $1) JCALL4(GetByteArrayRegion, jenv, $input, 0, (jsize)$2, (jbyte *)$1); }
+%typemap(javadirectorin, descriptor="[B") (char *STRING, size_t LENGTH) "$jniinput"
+%apply (char *STRING, size_t LENGTH) { (char *STRING, int LENGTH) }
+
+/* java keywords */
+%include <javakw.swg>
+
+// Default enum handling
+%include <enumtypesafe.swg>
+
diff --git a/share/swig/2.0.11/java/javahead.swg b/share/swig/3.0.12/java/javahead.swg
index 685bba1..685bba1 100644
--- a/share/swig/2.0.11/java/javahead.swg
+++ b/share/swig/3.0.12/java/javahead.swg
diff --git a/share/swig/2.0.11/java/javakw.swg b/share/swig/3.0.12/java/javakw.swg
index 99cd547..99cd547 100644
--- a/share/swig/2.0.11/java/javakw.swg
+++ b/share/swig/3.0.12/java/javakw.swg
diff --git a/share/swig/3.0.12/java/std_array.i b/share/swig/3.0.12/java/std_array.i
new file mode 100644
index 0000000..cbacfe6
--- /dev/null
+++ b/share/swig/3.0.12/java/std_array.i
@@ -0,0 +1,42 @@
+/* -----------------------------------------------------------------------------
+ * std_array.i
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+
+namespace std {
+
+  template<class T, size_t N> class array {
+  public:
+    typedef T& reference;
+    typedef const T& const_reference;
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef T value_type;
+    typedef T* pointer;
+    typedef const T* const_pointer;
+    array();
+    array(const array& other);
+    size_type size() const;
+    %rename(isEmpty) empty;
+    bool empty() const;
+    void fill(const T& u);
+    %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("array 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("array index out of range");
+      }
+    }
+  };
+}
+
diff --git a/share/swig/3.0.12/java/std_auto_ptr.i b/share/swig/3.0.12/java/std_auto_ptr.i
new file mode 100644
index 0000000..9b3cd73
--- /dev/null
+++ b/share/swig/3.0.12/java/std_auto_ptr.i
@@ -0,0 +1,27 @@
+/*
+    The typemaps here allow to handle functions returning std::auto_ptr<>,
+    which is the most common use of this type. If you have functions taking it
+    as parameter, these typemaps can't be used for them and you need to do
+    something else (e.g. use shared_ptr<> which SWIG supports fully).
+ */
+
+%define %auto_ptr(TYPE)
+%typemap (jni) std::auto_ptr<TYPE > "jlong"
+%typemap (jtype) std::auto_ptr<TYPE > "long"
+%typemap (jstype) std::auto_ptr<TYPE > "$typemap(jstype, TYPE)"
+
+%typemap (out) std::auto_ptr<TYPE > %{
+   jlong lpp = 0;
+   *(TYPE**) &lpp = $1.release();
+   $result = lpp;
+%}
+%typemap(javaout) std::auto_ptr<TYPE > {
+     long cPtr = $jnicall;
+     return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
+   }
+%template() std::auto_ptr<TYPE >;
+%enddef
+
+namespace std {
+   template <class T> class auto_ptr {};
+} 
diff --git a/share/swig/2.0.11/java/std_common.i b/share/swig/3.0.12/java/std_common.i
index cee11e8..cee11e8 100644
--- a/share/swig/2.0.11/java/std_common.i
+++ b/share/swig/3.0.12/java/std_common.i
diff --git a/share/swig/2.0.11/java/std_deque.i b/share/swig/3.0.12/java/std_deque.i
index cb98f6c..cb98f6c 100644
--- a/share/swig/2.0.11/java/std_deque.i
+++ b/share/swig/3.0.12/java/std_deque.i
diff --git a/share/swig/3.0.12/java/std_except.i b/share/swig/3.0.12/java/std_except.i
new file mode 100644
index 0000000..91d2f92
--- /dev/null
+++ b/share/swig/3.0.12/java/std_except.i
@@ -0,0 +1,32 @@
+/* -----------------------------------------------------------------------------
+ * 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 <typeinfo>
+#include <stdexcept>
+%}
+
+namespace std 
+{
+  %ignore exception;
+  struct exception {};
+}
+
+%typemap(throws) std::bad_cast          "SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.what());\n return $null;"
+%typemap(throws) std::bad_exception     "SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.what());\n return $null;"
+%typemap(throws) std::domain_error      "SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.what());\n return $null;"
+%typemap(throws) std::exception         "SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.what());\n return $null;"
+%typemap(throws) std::invalid_argument  "SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, $1.what());\n return $null;"
+%typemap(throws) std::length_error      "SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, $1.what());\n return $null;"
+%typemap(throws) std::logic_error       "SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.what());\n return $null;"
+%typemap(throws) std::out_of_range      "SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, $1.what());\n return $null;"
+%typemap(throws) std::overflow_error    "SWIG_JavaThrowException(jenv, SWIG_JavaArithmeticException, $1.what());\n return $null;"
+%typemap(throws) std::range_error       "SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, $1.what());\n return $null;"
+%typemap(throws) std::runtime_error     "SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.what());\n return $null;"
+%typemap(throws) std::underflow_error   "SWIG_JavaThrowException(jenv, SWIG_JavaArithmeticException, $1.what());\n return $null;"
+
diff --git a/share/swig/2.0.11/java/std_map.i b/share/swig/3.0.12/java/std_map.i
index e7812f3..e7812f3 100644
--- a/share/swig/2.0.11/java/std_map.i
+++ b/share/swig/3.0.12/java/std_map.i
diff --git a/share/swig/2.0.11/java/std_pair.i b/share/swig/3.0.12/java/std_pair.i
index fe45ee6..fe45ee6 100644
--- a/share/swig/2.0.11/java/std_pair.i
+++ b/share/swig/3.0.12/java/std_pair.i
diff --git a/share/swig/2.0.11/java/std_shared_ptr.i b/share/swig/3.0.12/java/std_shared_ptr.i
index df87367..df87367 100644
--- a/share/swig/2.0.11/java/std_shared_ptr.i
+++ b/share/swig/3.0.12/java/std_shared_ptr.i
diff --git a/share/swig/3.0.12/java/std_string.i b/share/swig/3.0.12/java/std_string.i
new file mode 100644
index 0000000..830a896
--- /dev/null
+++ b/share/swig/3.0.12/java/std_string.i
@@ -0,0 +1,121 @@
+/* -----------------------------------------------------------------------------
+ * std_string.i
+ *
+ * Typemaps for std::string and const std::string&
+ * These are mapped to a Java 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(jni) string "jstring"
+%typemap(jtype) string "String"
+%typemap(jstype) string "String"
+%typemap(javadirectorin) string "$jniinput"
+%typemap(javadirectorout) string "$javacall"
+
+%typemap(in) string 
+%{ if(!$input) {
+     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
+     return $null;
+    } 
+    const char *$1_pstr = (const char *)jenv->GetStringUTFChars($input, 0); 
+    if (!$1_pstr) return $null;
+    $1.assign($1_pstr);
+    jenv->ReleaseStringUTFChars($input, $1_pstr); %}
+
+%typemap(directorout) string 
+%{ if(!$input) {
+     if (!jenv->ExceptionCheck()) {
+       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
+     }
+     return $null;
+   } 
+   const char *$1_pstr = (const char *)jenv->GetStringUTFChars($input, 0); 
+   if (!$1_pstr) return $null;
+   $result.assign($1_pstr);
+   jenv->ReleaseStringUTFChars($input, $1_pstr); %}
+
+%typemap(directorin,descriptor="Ljava/lang/String;") string 
+%{ $input = jenv->NewStringUTF($1.c_str());
+   Swig::LocalRefGuard $1_refguard(jenv, $input); %}
+
+%typemap(out) string 
+%{ $result = jenv->NewStringUTF($1.c_str()); %}
+
+%typemap(javain) string "$javainput"
+
+%typemap(javaout) string {
+    return $jnicall;
+  }
+
+%typemap(typecheck) string = char *;
+
+%typemap(throws) string
+%{ SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.c_str());
+   return $null; %}
+
+// const string &
+%typemap(jni) const string & "jstring"
+%typemap(jtype) const string & "String"
+%typemap(jstype) const string & "String"
+%typemap(javadirectorin) const string & "$jniinput"
+%typemap(javadirectorout) const string & "$javacall"
+
+%typemap(in) const string &
+%{ if(!$input) {
+     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
+     return $null;
+   }
+   const char *$1_pstr = (const char *)jenv->GetStringUTFChars($input, 0); 
+   if (!$1_pstr) return $null;
+   $*1_ltype $1_str($1_pstr);
+   $1 = &$1_str;
+   jenv->ReleaseStringUTFChars($input, $1_pstr); %}
+
+%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const string &
+%{ if(!$input) {
+     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
+     return $null;
+   }
+   const char *$1_pstr = (const char *)jenv->GetStringUTFChars($input, 0); 
+   if (!$1_pstr) return $null;
+   /* possible thread/reentrant code problem */
+   static $*1_ltype $1_str;
+   $1_str = $1_pstr;
+   $result = &$1_str;
+   jenv->ReleaseStringUTFChars($input, $1_pstr); %}
+
+%typemap(directorin,descriptor="Ljava/lang/String;") const string &
+%{ $input = jenv->NewStringUTF($1.c_str());
+   Swig::LocalRefGuard $1_refguard(jenv, $input); %}
+
+%typemap(out) const string & 
+%{ $result = jenv->NewStringUTF($1->c_str()); %}
+
+%typemap(javain) const string & "$javainput"
+
+%typemap(javaout) const string & {
+    return $jnicall;
+  }
+
+%typemap(typecheck) const string & = char *;
+
+%typemap(throws) const string &
+%{ SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.c_str());
+   return $null; %}
+
+}
+
diff --git a/share/swig/3.0.12/java/std_vector.i b/share/swig/3.0.12/java/std_vector.i
new file mode 100644
index 0000000..971b426
--- /dev/null
+++ b/share/swig/3.0.12/java/std_vector.i
@@ -0,0 +1,85 @@
+/* -----------------------------------------------------------------------------
+ * std_vector.i
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.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 {
+            bool 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");
+            }
+        }
+    };
+}
+
+%define specialize_std_vector(T)
+#warning "specialize_std_vector - specialization for type T no longer needed"
+%enddef
+
diff --git a/share/swig/3.0.12/java/std_wstring.i b/share/swig/3.0.12/java/std_wstring.i
new file mode 100644
index 0000000..dd0b2f5
--- /dev/null
+++ b/share/swig/3.0.12/java/std_wstring.i
@@ -0,0 +1,174 @@
+/* -----------------------------------------------------------------------------
+ * std_wstring.i
+ *
+ * Typemaps for std::wstring and const std::wstring&
+ *
+ * These are mapped to a Java String and are passed around by value.
+ * Warning: Unicode / multibyte characters are handled differently on different 
+ * OSs so the std::wstring typemaps may not always work as intended.
+ *
+ * To use non-const std::wstring references use the following %apply.  Note 
+ * that they are passed by value.
+ * %apply const std::wstring & {std::wstring &};
+ * ----------------------------------------------------------------------------- */
+
+namespace std {
+
+%naturalvar wstring;
+
+class wstring;
+
+// wstring
+%typemap(jni) wstring "jstring"
+%typemap(jtype) wstring "String"
+%typemap(jstype) wstring "String"
+%typemap(javadirectorin) wstring "$jniinput"
+%typemap(javadirectorout) wstring "$javacall"
+
+%typemap(in) wstring
+%{if(!$input) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null std::wstring");
+    return $null;
+  }
+  const jchar *$1_pstr = jenv->GetStringChars($input, 0);
+  if (!$1_pstr) return $null;
+  jsize $1_len = jenv->GetStringLength($input);
+  if ($1_len) {
+    $1.reserve($1_len);
+    for (jsize i = 0; i < $1_len; ++i) {
+      $1.push_back((wchar_t)$1_pstr[i]);
+    }
+  }
+  jenv->ReleaseStringChars($input, $1_pstr);
+ %}
+
+%typemap(directorout) wstring
+%{if(!$input) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null std::wstring");
+    return $null;
+  }
+  const jchar *$1_pstr = jenv->GetStringChars($input, 0);
+  if (!$1_pstr) return $null;
+  jsize $1_len = jenv->GetStringLength($input);
+  if ($1_len) {
+    $result.reserve($1_len);
+    for (jsize i = 0; i < $1_len; ++i) {
+      $result.push_back((wchar_t)$1_pstr[i]);
+    }
+  }
+  jenv->ReleaseStringChars($input, $1_pstr);
+ %}
+
+%typemap(directorin,descriptor="Ljava/lang/String;") wstring %{
+  jsize $1_len = $1.length();
+  jchar *$1_conv_buf = new jchar[$1_len];
+  for (jsize i = 0; i < $1_len; ++i) {
+    $1_conv_buf[i] = (jchar)$1[i];
+  }
+  $input = jenv->NewString($1_conv_buf, $1_len);
+  Swig::LocalRefGuard $1_refguard(jenv, $input);
+  delete [] $1_conv_buf;
+%}
+
+%typemap(out) wstring
+%{jsize $1_len = $1.length();
+  jchar *conv_buf = new jchar[$1_len];
+  for (jsize i = 0; i < $1_len; ++i) {
+    conv_buf[i] = (jchar)$1[i];
+  }
+  $result = jenv->NewString(conv_buf, $1_len);
+  delete [] conv_buf; %}
+
+%typemap(javain) wstring "$javainput"
+
+%typemap(javaout) wstring {
+    return $jnicall;
+  }
+
+//%typemap(typecheck) wstring = wchar_t *;
+
+%typemap(throws) wstring
+%{ std::string message($1.begin(), $1.end());
+   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, message.c_str());
+   return $null; %}
+
+// const wstring &
+%typemap(jni) const wstring & "jstring"
+%typemap(jtype) const wstring & "String"
+%typemap(jstype) const wstring & "String"
+%typemap(javadirectorin) const wstring & "$jniinput"
+%typemap(javadirectorout) const wstring & "$javacall"
+
+%typemap(in) const wstring &
+%{if(!$input) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null std::wstring");
+    return $null;
+  }
+  const jchar *$1_pstr = jenv->GetStringChars($input, 0);
+  if (!$1_pstr) return $null;
+  jsize $1_len = jenv->GetStringLength($input);
+  std::wstring $1_str;
+  if ($1_len) {
+    $1_str.reserve($1_len);
+    for (jsize i = 0; i < $1_len; ++i) {
+      $1_str.push_back((wchar_t)$1_pstr[i]);
+    }
+  }
+  $1 = &$1_str;
+  jenv->ReleaseStringChars($input, $1_pstr);
+ %}
+
+%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const wstring & 
+%{if(!$input) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null std::wstring");
+    return $null;
+  }
+  const jchar *$1_pstr = jenv->GetStringChars($input, 0);
+  if (!$1_pstr) return $null;
+  jsize $1_len = jenv->GetStringLength($input);
+  /* possible thread/reentrant code problem */
+  static std::wstring $1_str;
+  if ($1_len) {
+    $1_str.reserve($1_len);
+    for (jsize i = 0; i < $1_len; ++i) {
+      $1_str.push_back((wchar_t)$1_pstr[i]);
+    }
+  }
+  $result = &$1_str;
+  jenv->ReleaseStringChars($input, $1_pstr); %}
+
+%typemap(directorin,descriptor="Ljava/lang/String;") const wstring & %{
+  jsize $1_len = $1.length();
+  jchar *$1_conv_buf = new jchar[$1_len];
+  for (jsize i = 0; i < $1_len; ++i) {
+    $1_conv_buf[i] = (jchar)($1)[i];
+  }
+  $input = jenv->NewString($1_conv_buf, $1_len);
+  Swig::LocalRefGuard $1_refguard(jenv, $input);
+  delete [] $1_conv_buf;
+%}
+
+%typemap(out) const wstring & 
+%{jsize $1_len = $1->length();
+  jchar *conv_buf = new jchar[$1_len];
+  for (jsize i = 0; i < $1_len; ++i) {
+    conv_buf[i] = (jchar)(*$1)[i];
+  }
+  $result = jenv->NewString(conv_buf, $1_len);
+  delete [] conv_buf; %}
+
+%typemap(javain) const wstring & "$javainput"
+
+%typemap(javaout) const wstring & {
+    return $jnicall;
+  }
+
+//%typemap(typecheck) const wstring & = wchar_t *;
+
+%typemap(throws) const wstring &
+%{ std::string message($1.begin(), $1.end());
+   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, message.c_str());
+   return $null; %}
+
+}
+
diff --git a/share/swig/2.0.11/java/stl.i b/share/swig/3.0.12/java/stl.i
index 04f8601..04f8601 100644
--- a/share/swig/2.0.11/java/stl.i
+++ b/share/swig/3.0.12/java/stl.i
diff --git a/share/swig/3.0.12/java/swiginterface.i b/share/swig/3.0.12/java/swiginterface.i
new file mode 100644
index 0000000..3344641
--- /dev/null
+++ b/share/swig/3.0.12/java/swiginterface.i
@@ -0,0 +1,74 @@
+/* -----------------------------------------------------------------------------
+ * swiginterface.i
+ *
+ * SWIG interface feature and typemaps implementation providing:
+ *   %interface
+ *   %interface_impl
+ *   %interface_custom
+ * ----------------------------------------------------------------------------- */
+
+%define INTERFACE_TYPEMAPS(CTYPE...)
+%typemap(jtype) CTYPE, CTYPE *, CTYPE *const&, CTYPE [], CTYPE & "long"
+%typemap(jstype) CTYPE "$&javainterfacename"
+%typemap(jstype) CTYPE *, CTYPE [], CTYPE & "$javainterfacename"
+%typemap(jstype) CTYPE *const& "$*javainterfacename"
+%typemap(javain) CTYPE "$javainput.$&interfacename_GetInterfaceCPtr()"
+%typemap(javain) CTYPE & "$javainput.$interfacename_GetInterfaceCPtr()"
+%typemap(javain) CTYPE *, CTYPE [] "($javainput == null) ? 0 : $javainput.$interfacename_GetInterfaceCPtr()"
+%typemap(javain) CTYPE *const& "($javainput == null) ? 0 : $javainput.$*interfacename_GetInterfaceCPtr()"
+%typemap(javaout) CTYPE {
+    return ($&javainterfacename)new $&javaclassname($jnicall, true);
+  }
+%typemap(javaout) CTYPE & {
+    return ($javainterfacename)new $javaclassname($jnicall, $owner);
+  }
+%typemap(javaout) CTYPE *, CTYPE [] {
+    long cPtr = $jnicall;
+    return (cPtr == 0) ? null : ($javainterfacename)new $javaclassname(cPtr, $owner);
+  }
+%typemap(javaout) CTYPE *const& {
+    long cPtr = $jnicall;
+    return (cPtr == 0) ? null : ($javainterfacename)new $javaclassname(cPtr, $owner);
+  }
+
+%typemap(javadirectorin) CTYPE "($&javainterfacename)new $&javaclassname($jniinput, true)"
+%typemap(javadirectorin) CTYPE & "($javainterfacename)new $javaclassname($jniinput, false)"
+%typemap(javadirectorin) CTYPE *, CTYPE [] "($jniinput == 0) ? null : ($javainterfacename)new $javaclassname($jniinput, false)"
+%typemap(javadirectorin) CTYPE *const& "($jniinput == 0) ? null : ($*javainterfacename)new $*javaclassname($jniinput, false)"
+%typemap(javadirectorout) CTYPE "$javacall.$&interfacename_GetInterfaceCPtr()"
+%typemap(javadirectorout) CTYPE *, CTYPE [], CTYPE & "$javacall.$interfacename_GetInterfaceCPtr()"
+%typemap(javadirectorout) CTYPE *const& "$javacall.$*interfacename_GetInterfaceCPtr()"
+%typemap(directorin,descriptor="L$packagepath/$&javainterfacename;") CTYPE
+%{ $input = 0;
+   *(($&1_ltype*)&$input) = new $1_ltype((const $1_ltype &)$1); %}
+%typemap(directorin,descriptor="L$packagepath/$javainterfacename;") CTYPE *, CTYPE []
+%{ *(($&1_ltype)&$input) = ($1_ltype) $1; %}
+%typemap(directorin,descriptor="L$packagepath/$javainterfacename;") CTYPE &
+%{ *($&1_ltype)&$input = ($1_ltype) &$1; %}
+%typemap(directorin,descriptor="L$packagepath/$*javainterfacename;") CTYPE *const&
+%{ *($&1_ltype)&$input = ($1_ltype) &$1; %}
+
+%typemap(javainterfacecode, declaration="  long $interfacename_GetInterfaceCPtr();\n", cptrmethod="$interfacename_GetInterfaceCPtr") CTYPE %{
+  public long $interfacename_GetInterfaceCPtr() {
+    return $imclassname.$javaclazzname$interfacename_GetInterfaceCPtr(swigCPtr);
+  }
+%}
+%enddef
+
+%define %interface(CTYPE...)
+%feature("interface", name="%sSwigInterface") CTYPE;
+INTERFACE_TYPEMAPS(CTYPE)
+%enddef
+
+%define %interface_impl(CTYPE...)
+%rename("%sSwigImpl") CTYPE;
+%feature("interface", name="%(rstrip:[SwigImpl])s") CTYPE;
+INTERFACE_TYPEMAPS(CTYPE)
+%enddef
+
+%define %interface_custom(PROXY, INTERFACE, CTYPE...)
+%rename(PROXY) CTYPE;
+%feature("interface", name=INTERFACE) CTYPE;
+INTERFACE_TYPEMAPS(CTYPE)
+%enddef
+
diff --git a/share/swig/3.0.12/java/typemaps.i b/share/swig/3.0.12/java/typemaps.i
new file mode 100644
index 0000000..4170915
--- /dev/null
+++ b/share/swig/3.0.12/java/typemaps.i
@@ -0,0 +1,479 @@
+/* -----------------------------------------------------------------------------
+ * 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 Java you could then use it like this:
+        double 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, JNITYPE, JTYPE, JNIDESC)
+%typemap(jni) TYPE *INPUT, TYPE &INPUT "JNITYPE"
+%typemap(jtype) TYPE *INPUT, TYPE &INPUT "JTYPE"
+%typemap(jstype) TYPE *INPUT, TYPE &INPUT "JTYPE"
+%typemap(javain) TYPE *INPUT, TYPE &INPUT "$javainput"
+
+%typemap(in) TYPE *INPUT, TYPE &INPUT
+%{ $1 = ($1_ltype)&$input; %}
+
+%typemap(freearg) TYPE *INPUT, TYPE &INPUT ""
+
+%typemap(typecheck) TYPE *INPUT = TYPE;
+%typemap(typecheck) TYPE &INPUT = TYPE;
+%enddef
+
+INPUT_TYPEMAP(bool, jboolean, boolean, "Z");
+INPUT_TYPEMAP(signed char, jbyte, byte, "B");
+INPUT_TYPEMAP(unsigned char, jshort, short, "S");
+INPUT_TYPEMAP(short, jshort, short, "S");
+INPUT_TYPEMAP(unsigned short, jint, int, "I");
+INPUT_TYPEMAP(int, jint, int, "I");
+INPUT_TYPEMAP(unsigned int, jlong, long, "J");
+INPUT_TYPEMAP(long, jint, int, "I");
+INPUT_TYPEMAP(unsigned long, jlong, long, "J");
+INPUT_TYPEMAP(long long, jlong, long, "J");
+INPUT_TYPEMAP(unsigned long long, jobject, java.math.BigInteger, "Ljava/math/BigInteger;");
+INPUT_TYPEMAP(float, jfloat, float, "F");
+INPUT_TYPEMAP(double, jdouble, double, "D");
+
+#undef INPUT_TYPEMAP
+
+/* Convert from BigInteger using the toByteArray member function */
+/* Overrides the typemap in the INPUT_TYPEMAP macro */
+%typemap(in) unsigned long long *INPUT($*1_ltype temp), unsigned long long &INPUT($*1_ltype temp) {
+  jclass clazz;
+  jmethodID mid;
+  jbyteArray ba;
+  jbyte* bae;
+  jsize sz;
+  int i;
+
+  if (!$input) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
+    return $null;
+  }
+  clazz = JCALL1(GetObjectClass, jenv, $input);
+  mid = JCALL3(GetMethodID, jenv, clazz, "toByteArray", "()[B");
+  ba = (jbyteArray)JCALL2(CallObjectMethod, jenv, $input, mid);
+  bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
+  sz = JCALL1(GetArrayLength, jenv, ba);
+  temp = 0;
+  if (sz > 0) {
+    temp = ($*1_ltype)(signed char)bae[0];
+    for(i=1; i<sz; i++) {
+      temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
+    }
+  }
+  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
+  $1 = &temp;
+}
+
+// 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 
+Java array being passed as a parameter where a c pointer or reference is required. 
+As with any Java 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 Java output of the function would be the function return value and the 
+value in the single element array. In Java you would use it like this:
+
+    double[] ptr = {0.0};
+    double 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);
+*/
+
+/* Java BigInteger[] */
+%typecheck(SWIG_TYPECHECK_INT128_ARRAY) SWIGBIGINTEGERARRAY ""
+
+%define OUTPUT_TYPEMAP(TYPE, JNITYPE, JTYPE, JAVATYPE, JNIDESC, TYPECHECKTYPE)
+%typemap(jni) TYPE *OUTPUT, TYPE &OUTPUT %{JNITYPE##Array%}
+%typemap(jtype) TYPE *OUTPUT, TYPE &OUTPUT "JTYPE[]"
+%typemap(jstype) TYPE *OUTPUT, TYPE &OUTPUT "JTYPE[]"
+%typemap(javain) TYPE *OUTPUT, TYPE &OUTPUT "$javainput"
+%typemap(javadirectorin) TYPE *OUTPUT, TYPE &OUTPUT "$jniinput"
+%typemap(javadirectorout) TYPE *OUTPUT, TYPE &OUTPUT "$javacall"
+
+%typemap(in) TYPE *OUTPUT($*1_ltype temp), TYPE &OUTPUT($*1_ltype temp)
+{
+  if (!$input) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
+    return $null;
+  }
+  if (JCALL1(GetArrayLength, jenv, $input) == 0) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
+    return $null;
+  }
+  temp = ($*1_ltype)0;
+  $1 = &temp; 
+}
+
+%typemap(freearg) TYPE *OUTPUT, TYPE &OUTPUT ""
+
+%typemap(argout) TYPE *OUTPUT, TYPE &OUTPUT
+{
+  JNITYPE jvalue = (JNITYPE)temp$argnum;
+  JCALL4(Set##JAVATYPE##ArrayRegion, jenv, $input, 0, 1, &jvalue);
+}
+
+%typemap(directorin,descriptor=JNIDESC) TYPE &OUTPUT, TYPE *OUTPUT %{
+  $input = JCALL1(New##JAVATYPE##Array, jenv, 1);
+  Swig::LocalRefGuard $1_refguard(jenv, $input); %}
+
+%typemap(directorargout, noblock=1) TYPE &OUTPUT
+{
+  JNITYPE $1_jvalue;
+  JCALL4(Get##JAVATYPE##ArrayRegion, jenv, $input, 0, 1, &$1_jvalue);
+  $result = $1_jvalue;
+}
+
+%typemap(directorargout, noblock=1) TYPE *OUTPUT
+{
+  JNITYPE $1_jvalue;
+  JCALL4(Get##JAVATYPE##ArrayRegion, jenv, $input, 0, 1, &$1_jvalue);
+  *$result = $1_jvalue;
+}
+
+%typemap(typecheck) TYPE *OUTPUT = TYPECHECKTYPE;
+%typemap(typecheck) TYPE &OUTPUT = TYPECHECKTYPE;
+%enddef
+
+OUTPUT_TYPEMAP(bool, jboolean, boolean, Boolean, "[Z", jbooleanArray);
+OUTPUT_TYPEMAP(signed char, jbyte, byte, Byte, "[B", jbyteArray);
+OUTPUT_TYPEMAP(unsigned char, jshort, short, Short, "[S", jshortArray);
+OUTPUT_TYPEMAP(short, jshort, short, Short, "[S", jshortArray);
+OUTPUT_TYPEMAP(unsigned short, jint, int, Int, "[I", jintArray);
+OUTPUT_TYPEMAP(int, jint, int, Int, "[I", jintArray);
+OUTPUT_TYPEMAP(unsigned int, jlong, long, Long, "[J", jlongArray);
+OUTPUT_TYPEMAP(long, jint, int, Int, "[I", jintArray);
+OUTPUT_TYPEMAP(unsigned long, jlong, long, Long, "[J", jlongArray);
+OUTPUT_TYPEMAP(long long, jlong, long, Long, "[J", jlongArray);
+OUTPUT_TYPEMAP(unsigned long long, jobject, java.math.BigInteger, Object, "[Ljava/math/BigInteger;", jobjectArray);
+OUTPUT_TYPEMAP(float, jfloat, float, Float, "[F", jfloatArray);
+OUTPUT_TYPEMAP(double, jdouble, double, Double, "[D", jdoubleArray);
+
+#undef OUTPUT_TYPEMAP
+
+%typemap(in) bool *OUTPUT($*1_ltype temp), bool &OUTPUT($*1_ltype temp)
+{
+  if (!$input) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
+    return $null;
+  }
+  if (JCALL1(GetArrayLength, jenv, $input) == 0) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
+    return $null;
+  }
+  temp = false;
+  $1 = &temp; 
+}
+
+/* Convert to BigInteger - byte array holds number in 2's complement big endian format */
+/* Use first element in BigInteger array for output */
+/* Overrides the typemap in the OUTPUT_TYPEMAP macro */
+%typemap(argout) unsigned long long *OUTPUT, unsigned long long &OUTPUT { 
+  jbyteArray ba = JCALL1(NewByteArray, jenv, 9);
+  jbyte* bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
+  jclass clazz = JCALL1(FindClass, jenv, "java/math/BigInteger");
+  jmethodID mid = JCALL3(GetMethodID, jenv, clazz, "<init>", "([B)V");
+  jobject bigint;
+  int i;
+
+  bae[0] = 0;
+  for(i=1; i<9; i++ ) {
+    bae[i] = (jbyte)(temp$argnum>>8*(8-i));
+  }
+
+  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
+  bigint = JCALL3(NewObject, jenv, clazz, mid, ba);
+  JCALL1(DeleteLocalRef, jenv, ba);
+  JCALL3(SetObjectArrayElement, jenv, $input, 0, bigint);
+}
+
+/*
+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 Java array.
+
+        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.
+
+       double x[] = {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 Java 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, JNITYPE, JTYPE, JAVATYPE, JNIDESC, TYPECHECKTYPE)
+%typemap(jni) TYPE *INOUT, TYPE &INOUT %{JNITYPE##Array%}
+%typemap(jtype) TYPE *INOUT, TYPE &INOUT "JTYPE[]"
+%typemap(jstype) TYPE *INOUT, TYPE &INOUT "JTYPE[]"
+%typemap(javain) TYPE *INOUT, TYPE &INOUT "$javainput"
+%typemap(javadirectorin) TYPE *INOUT, TYPE &INOUT "$jniinput"
+%typemap(javadirectorout) TYPE *INOUT, TYPE &INOUT "$javacall"
+
+%typemap(in) TYPE *INOUT, TYPE &INOUT {
+  if (!$input) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
+    return $null;
+  }
+  if (JCALL1(GetArrayLength, jenv, $input) == 0) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
+    return $null;
+  }
+  $1 = ($1_ltype) JCALL2(Get##JAVATYPE##ArrayElements, jenv, $input, 0); 
+}
+
+%typemap(freearg) TYPE *INOUT, TYPE &INOUT ""
+
+%typemap(argout) TYPE *INOUT, TYPE &INOUT
+{ JCALL3(Release##JAVATYPE##ArrayElements, jenv, $input, (JNITYPE *)$1, 0); }
+
+%typemap(directorin,descriptor=JNIDESC) TYPE &INOUT %{
+  $input = JCALL1(New##JAVATYPE##Array, jenv, 1);
+  JNITYPE $1_jvalue = (JNITYPE)$1;
+  JCALL4(Set##JAVATYPE##ArrayRegion, jenv, $input, 0, 1, &$1_jvalue);
+  Swig::LocalRefGuard $1_refguard(jenv, $input); %}
+
+%typemap(directorin,descriptor=JNIDESC) TYPE *INOUT %{
+  $input = JCALL1(New##JAVATYPE##Array, jenv, 1);
+  JNITYPE $1_jvalue = (JNITYPE)*$1;
+  JCALL4(Set##JAVATYPE##ArrayRegion, jenv, $input, 0, 1, &$1_jvalue);
+  Swig::LocalRefGuard $1_refguard(jenv, $input); %}
+
+%typemap(directorargout, noblock=1) TYPE &INOUT
+{
+  JCALL4(Get##JAVATYPE##ArrayRegion, jenv, $input, 0, 1, &$1_jvalue);
+  $result = $1_jvalue;
+}
+
+%typemap(directorargout, noblock=1) TYPE *INOUT
+{
+  JCALL4(Get##JAVATYPE##ArrayRegion, jenv, $input, 0, 1, &$1_jvalue);
+  *$result = $1_jvalue;
+}
+
+%typemap(typecheck) TYPE *INOUT = TYPECHECKTYPE;
+%typemap(typecheck) TYPE &INOUT = TYPECHECKTYPE;
+%enddef
+
+INOUT_TYPEMAP(bool, jboolean, boolean, Boolean, "[Z", jbooleanArray);
+INOUT_TYPEMAP(signed char, jbyte, byte, Byte, "[B", jbyteArray);
+INOUT_TYPEMAP(unsigned char, jshort, short, Short, "[S", jshortArray);
+INOUT_TYPEMAP(short, jshort, short, Short, "[S", jshortArray);
+INOUT_TYPEMAP(unsigned short, jint, int, Int, "[I", jintArray);
+INOUT_TYPEMAP(int, jint, int, Int, "[I", jintArray);
+INOUT_TYPEMAP(unsigned int, jlong, long, Long, "[J", jlongArray);
+INOUT_TYPEMAP(long, jint, int, Int, "[I", jintArray);
+INOUT_TYPEMAP(unsigned long, jlong, long, Long, "[J", jlongArray);
+INOUT_TYPEMAP(long long, jlong, long, Long, "[J", jlongArray);
+INOUT_TYPEMAP(unsigned long long, jobject, java.math.BigInteger, Object, "[java/math/BigInteger;", jobjectArray);
+INOUT_TYPEMAP(float, jfloat, float, Float, "[F", jfloatArray);
+INOUT_TYPEMAP(double, jdouble, double, Double, "[D", jdoubleArray);
+
+#undef INOUT_TYPEMAP
+
+/* Override typemaps in the INOUT_TYPEMAP macro for booleans to fix casts
+   as a jboolean isn't always the same size as a bool */
+%typemap(in) bool *INOUT (bool btemp, jboolean *jbtemp), bool &INOUT (bool btemp, jboolean *jbtemp) {
+  if (!$input) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
+    return $null;
+  }
+  if (JCALL1(GetArrayLength, jenv, $input) == 0) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
+    return $null;
+  }
+  jbtemp = JCALL2(GetBooleanArrayElements, jenv, $input, 0);
+  btemp = (*jbtemp) ? true : false;
+  $1 = &btemp;
+}
+
+%typemap(argout) bool *INOUT, bool &INOUT {
+  *jbtemp$argnum = btemp$argnum ? (jboolean)1 : (jboolean)0;
+  JCALL3(ReleaseBooleanArrayElements, jenv, $input , (jboolean *)jbtemp$argnum, 0);
+}
+
+/* Override the typemap in the INOUT_TYPEMAP macro for unsigned long long */
+%typemap(in) unsigned long long *INOUT ($*1_ltype temp), unsigned long long &INOUT ($*1_ltype temp) { 
+  jobject bigint;
+  jclass clazz;
+  jmethodID mid;
+  jbyteArray ba;
+  jbyte* bae;
+  jsize sz;
+  int i;
+
+  if (!$input) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
+    return $null;
+  }
+  if (JCALL1(GetArrayLength, jenv, $input) == 0) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
+    return $null;
+  }
+  bigint = JCALL2(GetObjectArrayElement, jenv, $input, 0);
+  if (!bigint) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array element null");
+    return $null;
+  }
+  clazz = JCALL1(GetObjectClass, jenv, bigint);
+  mid = JCALL3(GetMethodID, jenv, clazz, "toByteArray", "()[B");
+  ba = (jbyteArray)JCALL2(CallObjectMethod, jenv, bigint, mid);
+  bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
+  sz = JCALL1(GetArrayLength, jenv, ba);
+  temp = 0;
+  if (sz > 0) {
+    temp = ($*1_ltype)(signed char)bae[0];
+    for(i=1; i<sz; i++) {
+      temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
+    }
+  }
+  JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
+  $1 = &temp;
+}
+
+%typemap(argout) unsigned long long *INOUT = unsigned long long *OUTPUT;
+%typemap(argout) unsigned long long &INOUT = unsigned long long &OUTPUT;
diff --git a/share/swig/3.0.12/java/various.i b/share/swig/3.0.12/java/various.i
new file mode 100644
index 0000000..76fb2b1
--- /dev/null
+++ b/share/swig/3.0.12/java/various.i
@@ -0,0 +1,194 @@
+/* -----------------------------------------------------------------------------
+ * various.i
+ *
+ * SWIG Typemap library for Java.
+ * Various useful typemaps.
+ * ----------------------------------------------------------------------------- */
+
+/* 
+ * char **STRING_ARRAY typemaps. 
+ * These typemaps are for C String arrays which are NULL terminated.
+ *   char *values[] = { "one", "two", "three", NULL }; // note NULL
+ * char ** is mapped to a Java String[].
+ *
+ * Example usage wrapping:
+ *   %apply char **STRING_ARRAY { char **input };
+ *   char ** foo(char **input);
+ *  
+ * Java usage:
+ *   String numbers[] = { "one", "two", "three" };
+ *   String[] ret = modulename.foo( numbers };
+ */
+%typemap(jni) char **STRING_ARRAY "jobjectArray"
+%typemap(jtype) char **STRING_ARRAY "String[]"
+%typemap(jstype) char **STRING_ARRAY "String[]"
+%typemap(in) char **STRING_ARRAY (jint size) {
+  int i = 0;
+  if ($input) {
+    size = JCALL1(GetArrayLength, jenv, $input);
+#ifdef __cplusplus
+    $1 = new char*[size+1];
+#else
+    $1 = (char **)malloc((size+1) * sizeof(char *));
+#endif
+    for (i = 0; i<size; i++) {
+      jstring j_string = (jstring)JCALL2(GetObjectArrayElement, jenv, $input, i);
+      const char *c_string = JCALL2(GetStringUTFChars, jenv, j_string, 0);
+#ifdef __cplusplus
+      $1[i] = new char [strlen(c_string)+1];
+#else
+      $1[i] = (char *)malloc((strlen(c_string)+1) * sizeof(const char *));
+#endif
+      strcpy($1[i], c_string);
+      JCALL2(ReleaseStringUTFChars, jenv, j_string, c_string);
+      JCALL1(DeleteLocalRef, jenv, j_string);
+    }
+    $1[i] = 0;
+  } else {
+    $1 = 0;
+    size = 0;
+  }
+}
+
+%typemap(freearg) char **STRING_ARRAY {
+  int i;
+  for (i=0; i<size$argnum; i++)
+#ifdef __cplusplus
+    delete[] $1[i];
+  delete[] $1;
+#else
+  free($1[i]);
+  free($1);
+#endif
+}
+
+%typemap(out) char **STRING_ARRAY {
+  if ($1) {
+    int i;
+    jsize len=0;
+    jstring temp_string;
+    const jclass clazz = JCALL1(FindClass, jenv, "java/lang/String");
+
+    while ($1[len]) len++;
+    $result = JCALL3(NewObjectArray, jenv, len, clazz, NULL);
+    /* exception checking omitted */
+
+    for (i=0; i<len; i++) {
+      temp_string = JCALL1(NewStringUTF, jenv, *$1++);
+      JCALL3(SetObjectArrayElement, jenv, $result, i, temp_string);
+      JCALL1(DeleteLocalRef, jenv, temp_string);
+    }
+  }
+}
+
+%typemap(javain) char **STRING_ARRAY "$javainput"
+%typemap(javaout) char **STRING_ARRAY {
+    return $jnicall;
+  }
+
+/* 
+ * char **STRING_OUT typemaps. 
+ * These are typemaps for returning strings when using a C char ** parameter type.
+ * The returned string appears in the 1st element of the passed in Java String array.
+ *
+ * Example usage wrapping:
+ *   %apply char **STRING_OUT { char **string_out };
+ *   void foo(char **string_out);
+ *  
+ * Java usage:
+ *   String stringOutArray[] = { "" };
+ *   modulename.foo(stringOutArray);
+ *   System.out.println( stringOutArray[0] );
+ */
+%typemap(jni) char **STRING_OUT "jobjectArray"
+%typemap(jtype) char **STRING_OUT "String[]"
+%typemap(jstype) char **STRING_OUT "String[]"
+%typemap(javain) char **STRING_OUT "$javainput"
+
+%typemap(in) char **STRING_OUT($*1_ltype temp) {
+  if (!$input) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
+    return $null;
+  }
+  if (JCALL1(GetArrayLength, jenv, $input) == 0) {
+    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
+    return $null;
+  }
+  $1 = &temp; 
+  *$1 = 0;
+}
+
+%typemap(argout) char **STRING_OUT {
+  jstring jnewstring = NULL;
+  if ($1) {
+     jnewstring = JCALL1(NewStringUTF, jenv, *$1);
+  }
+  JCALL3(SetObjectArrayElement, jenv, $input, 0, jnewstring); 
+}
+
+/* 
+ * char *BYTE typemaps. 
+ * These are input typemaps for mapping a Java byte[] array to a C char array.
+ * Note that as a Java array is used and thus passeed by reference, the C routine 
+ * can return data to Java via the parameter.
+ *
+ * Example usage wrapping:
+ *   void foo(char *array);
+ *  
+ * Java usage:
+ *   byte b[] = new byte[20];
+ *   modulename.foo(b);
+ */
+%typemap(jni) char *BYTE "jbyteArray"
+%typemap(jtype) char *BYTE "byte[]"
+%typemap(jstype) char *BYTE "byte[]"
+%typemap(in) char *BYTE {
+  $1 = (char *) JCALL2(GetByteArrayElements, jenv, $input, 0); 
+}
+
+%typemap(argout) char *BYTE {
+  JCALL3(ReleaseByteArrayElements, jenv, $input, (jbyte *) $1, 0); 
+}
+
+%typemap(javain) char *BYTE "$javainput"
+
+/* Prevent default freearg typemap from being used */
+%typemap(freearg) char *BYTE ""
+
+/* 
+ * unsigned char *NIOBUFFER typemaps. 
+ * This is for mapping Java nio buffers to C char arrays.
+ * It is useful for performance critical code as it reduces the memory copy an marshaling overhead.
+ * Note: The Java buffer has to be allocated with allocateDirect.
+ *
+ * Example usage wrapping:
+ *   %apply unsigned char *NIOBUFFER { unsigned char *buf };
+ *   void foo(unsigned char *buf);
+ *  
+ * Java usage:
+ *   java.nio.ByteBuffer b = ByteBuffer.allocateDirect(20); 
+ *   modulename.foo(b);
+ */
+%typemap(jni) unsigned char *NIOBUFFER "jobject"  
+%typemap(jtype) unsigned char *NIOBUFFER "java.nio.ByteBuffer"  
+%typemap(jstype) unsigned char *NIOBUFFER "java.nio.ByteBuffer"  
+%typemap(javain,
+  pre="  assert $javainput.isDirect() : \"Buffer must be allocated direct.\";") unsigned char *NIOBUFFER "$javainput"
+%typemap(javaout) unsigned char *NIOBUFFER {  
+  return $jnicall;  
+}  
+%typemap(in) unsigned char *NIOBUFFER {  
+  $1 = (unsigned char *) JCALL1(GetDirectBufferAddress, jenv, $input); 
+  if ($1 == NULL) {  
+    SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of a java.nio.ByteBuffer direct byte buffer. Buffer must be a direct buffer and not a non-direct buffer.");  
+  }  
+}  
+%typemap(memberin) unsigned char *NIOBUFFER {  
+  if ($input) {  
+    $1 = $input;  
+  } else {  
+    $1 = 0;  
+  }  
+}  
+%typemap(freearg) unsigned char *NIOBUFFER ""  
+
diff --git a/share/swig/3.0.12/javascript/jsc/arrays_javascript.i b/share/swig/3.0.12/javascript/jsc/arrays_javascript.i
new file mode 100644
index 0000000..b9199d8
--- /dev/null
+++ b/share/swig/3.0.12/javascript/jsc/arrays_javascript.i
@@ -0,0 +1,123 @@
+/* -----------------------------------------------------------------------------
+ * arrays_javascript.i
+ *
+ * These typemaps give more natural support for arrays. The typemaps are not efficient
+ * as there is a lot of copying of the array values whenever the array is passed to C/C++
+ * from JavaScript and vice versa. The JavaScript array is expected to be the same size as the C array.
+ * An exception is thrown if they are not.
+ *
+ * Example usage:
+ * Wrapping:
+ *
+ *   %include <arrays_javascript.i>
+ *   %inline %{
+ *       extern int FiddleSticks[3];
+ *   %}
+ *
+ * Use from JavaScript like this:
+ *
+ *   var fs = [10, 11, 12];
+ *   example.FiddleSticks = fs;
+ *   fs = example.FiddleSticks;
+ * ----------------------------------------------------------------------------- */
+
+%fragment("SWIG_JSCGetIntProperty",    "header", fragment=SWIG_AsVal_frag(int)) {}
+%fragment("SWIG_JSCGetNumberProperty", "header", fragment=SWIG_AsVal_frag(double)) {}
+
+%typemap(in, fragment="SWIG_JSCGetIntProperty") int[], int[ANY]
+    (int length = 0, JSObjectRef array, JSValueRef jsvalue, int i = 0, int res = 0, $*1_ltype temp) {
+  if (JSValueIsObject(context, $input))
+  {
+    // Convert into Array
+    array = JSValueToObject(context, $input, NULL);
+
+    length = $1_dim0;
+
+    $1  = ($*1_ltype *)malloc(sizeof($*1_ltype) * length);
+
+    // Get each element from array
+    for (i = 0; i < length; i++)
+    {
+      jsvalue = JSObjectGetPropertyAtIndex(context, array, i, NULL);
+
+      // Get primitive value from JSObject
+      res = SWIG_AsVal(int)(jsvalue, &temp);
+      if (!SWIG_IsOK(res))
+      {
+        SWIG_exception_fail(SWIG_ERROR, "Failed to convert $input to double");
+      }
+      arg$argnum[i] = temp;
+    }
+
+  }
+  else
+  {
+    SWIG_exception_fail(SWIG_ERROR, "$input is not JSObjectRef");
+  }
+}
+
+%typemap(freearg) int[], int[ANY] {
+    free($1);
+}
+
+%typemap(out, fragment=SWIG_From_frag(int)) int[], int[ANY] (int length = 0, int i = 0)
+{
+  length = $1_dim0;
+  JSValueRef values[length];
+
+  for (i = 0; i < length; i++)
+  {
+    values[i] = SWIG_From(int)($1[i]);
+  }
+
+  $result = JSObjectMakeArray(context, length, values, NULL);
+}
+
+%typemap(in, fragment="SWIG_JSCGetNumberProperty") double[], double[ANY]
+    (int length = 0, JSObjectRef array, JSValueRef jsvalue, int i = 0, int res = 0, $*1_ltype temp) {
+  if (JSValueIsObject(context, $input))
+  {
+    // Convert into Array
+    array = JSValueToObject(context, $input, NULL);
+
+    length = $1_dim0;
+
+    $1  = ($*1_ltype *)malloc(sizeof($*1_ltype) * length);
+
+    // Get each element from array
+    for (i = 0; i < length; i++)
+    {
+      jsvalue = JSObjectGetPropertyAtIndex(context, array, i, NULL);
+
+      // Get primitive value from JSObject
+      res = SWIG_AsVal(double)(jsvalue, &temp);
+      if (!SWIG_IsOK(res))
+      {
+        SWIG_exception_fail(SWIG_ERROR, "Failed to convert $input to double");
+      }
+      arg$argnum[i] = temp;
+    }
+
+  }
+  else
+  {
+    SWIG_exception_fail(SWIG_ERROR, "$input is not JSObjectRef");
+  }
+}
+
+%typemap(freearg) double[], double[ANY] {
+    free($1);
+}
+
+%typemap(out, fragment=SWIG_From_frag(double)) double[], double[ANY] (int length = 0, int i = 0)
+{
+  length = $1_dim0;
+  JSValueRef values[length];
+
+  for (i = 0; i < length; i++)
+  {
+    values[i] = SWIG_From(double)($1[i]);
+  }
+
+  $result = JSObjectMakeArray(context, length, values, NULL);
+}
diff --git a/share/swig/3.0.12/javascript/jsc/ccomplex.i b/share/swig/3.0.12/javascript/jsc/ccomplex.i
new file mode 100644
index 0000000..50f0f95
--- /dev/null
+++ b/share/swig/3.0.12/javascript/jsc/ccomplex.i
@@ -0,0 +1,26 @@
+/* -----------------------------------------------------------------------------
+ * ccomplex.i
+ *
+ * C complex typemaps
+ * ISO C99:  7.3 Complex arithmetic <complex.h>
+ * ----------------------------------------------------------------------------- */
+
+
+%include <javascriptcomplex.swg>
+
+%{
+#include <complex.h>
+%}
+
+
+/* C complex constructor */
+#define CCplxConst(r, i) ((r) + I*(i))
+
+%swig_cplxflt_convn(float complex, CCplxConst, creal, cimag);
+%swig_cplxdbl_convn(double complex, CCplxConst, creal, cimag);
+%swig_cplxdbl_convn(complex, CCplxConst, creal, cimag);
+
+/* declaring the typemaps */
+%typemaps_primitive(SWIG_TYPECHECK_CPLXFLT, float complex);
+%typemaps_primitive(SWIG_TYPECHECK_CPLXDBL, double complex);
+%typemaps_primitive(SWIG_TYPECHECK_CPLXDBL, complex);
diff --git a/share/swig/2.0.11/octave/cdata.i b/share/swig/3.0.12/javascript/jsc/cdata.i
index 3679659..3679659 100644
--- a/share/swig/2.0.11/octave/cdata.i
+++ b/share/swig/3.0.12/javascript/jsc/cdata.i
diff --git a/share/swig/2.0.11/python/complex.i b/share/swig/3.0.12/javascript/jsc/complex.i
index 4c3b3c5..4c3b3c5 100644
--- a/share/swig/2.0.11/python/complex.i
+++ b/share/swig/3.0.12/javascript/jsc/complex.i
diff --git a/share/swig/3.0.12/javascript/jsc/exception.i b/share/swig/3.0.12/javascript/jsc/exception.i
new file mode 100644
index 0000000..0246cfd
--- /dev/null
+++ b/share/swig/3.0.12/javascript/jsc/exception.i
@@ -0,0 +1 @@
+%include <typemaps/exception.swg>
diff --git a/share/swig/3.0.12/javascript/jsc/javascript.swg b/share/swig/3.0.12/javascript/jsc/javascript.swg
new file mode 100644
index 0000000..3a83b64
--- /dev/null
+++ b/share/swig/3.0.12/javascript/jsc/javascript.swg
@@ -0,0 +1,19 @@
+/* -----------------------------------------------------------------------------
+ * javascript.swg
+ *
+ * Javascript typemaps
+ * ----------------------------------------------------------------------------- */
+
+%include <typemaps/swigmacros.swg>
+
+%include <javascripttypemaps.swg>
+
+%include <javascriptruntime.swg>
+
+%include <javascripthelpers.swg>
+
+%include <javascriptkw.swg>
+
+%include <javascriptcode.swg>
+
+%include <javascriptinit.swg>
diff --git a/share/swig/3.0.12/javascript/jsc/javascriptcode.swg b/share/swig/3.0.12/javascript/jsc/javascriptcode.swg
new file mode 100644
index 0000000..4b21c98
--- /dev/null
+++ b/share/swig/3.0.12/javascript/jsc/javascriptcode.swg
@@ -0,0 +1,429 @@
+/* -----------------------------------------------------------------------------
+ * js_ctor:  template for wrapping a ctor.
+ *   - $jswrapper:        wrapper of called ctor
+ *   - $jslocals:         locals part of wrapper
+ *   - $jscode:           code part of wrapper
+ *   - $jsargcount:       number of arguments
+ *   - $jsmangledtype:    mangled type of class
+ * ----------------------------------------------------------------------------- */
+%fragment ("js_ctor", "templates")
+%{
+static JSObjectRef $jswrapper(JSContextRef context, JSObjectRef thisObject, size_t argc, const JSValueRef argv[], JSValueRef* exception)
+{
+    $jslocals
+    if(argc != $jsargcount) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for $jswrapper.");
+
+    $jscode
+    return SWIG_JSC_NewPointerObj(context, result, SWIGTYPE_$jsmangledtype, SWIG_POINTER_OWN);
+    goto fail;
+    fail:
+    return NULL;
+}
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_veto_ctor:  a vetoing ctor for abstract classes
+ *   - $jswrapper:        name of wrapper
+ *   - $jsname:           class name
+ * ----------------------------------------------------------------------------- */
+%fragment ("js_veto_ctor", "templates")
+%{
+static JSObjectRef $jswrapper(JSContextRef context, JSObjectRef ctorObject,
+    size_t argc, const JSValueRef argv[], JSValueRef* exception)
+{
+    SWIG_exception(SWIG_ERROR, "Class $jsname can not be instantiated");
+fail:
+    return 0;
+}
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_ctor_dispatcher:  dispatcher for overloaded constructors
+ *   - $jswrapper:        name of wrapper
+ *   - $jsname:           class name
+ *   - $jsdispatchcases:  part containing code for dispatching
+ * ----------------------------------------------------------------------------- */
+%fragment ("js_ctor_dispatcher", "templates")
+%{
+static JSObjectRef $jswrapper(JSContextRef context, JSObjectRef ctorObject,
+    size_t argc, const JSValueRef argv[], JSValueRef* exception)
+{
+    JSObjectRef thisObject = NULL;
+
+    // switch all cases by means of series of if-returns.
+    $jsdispatchcases
+
+    // default:
+    SWIG_exception_fail(SWIG_ERROR, "Illegal arguments for construction of $jsname");
+
+    fail:
+    return thisObject;
+}
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_overloaded_ctor:  template for wrapping a ctor.
+ *   - $jswrapper:        wrapper of called ctor
+ *   - $jslocals:         locals part of wrapper
+ *   - $jscode:           code part of wrapper
+ *   - $jsargcount:       number of arguments
+ *   - $jsmangledtype:    mangled type of class
+ * ----------------------------------------------------------------------------- */
+%fragment ("js_overloaded_ctor", "templates")
+%{
+static JSObjectRef $jswrapper(JSContextRef context, JSObjectRef thisObject, size_t argc, const JSValueRef argv[], JSValueRef* exception)
+{
+    $jslocals
+    $jscode
+    return SWIG_JSC_NewPointerObj(context, result, SWIGTYPE_$jsmangledtype, SWIG_POINTER_OWN);
+
+    goto fail;
+    fail:
+    return NULL;
+}
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_ctor_dispatch_case:  template for a dispatch case for calling an overloaded ctor.
+ *   - $jsargcount:       number of arguments of called ctor
+ *   - $jswrapper:        wrapper of called ctor
+ *
+ *  Note: a try-catch-like mechanism is used to switch cases
+ * ----------------------------------------------------------------------------- */
+%fragment ("js_ctor_dispatch_case", "templates")
+%{
+  if(argc == $jsargcount) {
+    thisObject = $jswrapper(context, NULL, argc, argv, exception);
+    if(thisObject != NULL) { *exception=0; return thisObject; } /* reset exception and return */
+  }
+%}
+
+
+/* -----------------------------------------------------------------------------
+ * js_dtor:  template for a destructor wrapper
+ *   - $jsmangledname:  mangled class name
+ *   - $jstype:         class type
+ * ----------------------------------------------------------------------------- */
+%fragment ("js_dtor", "templates")
+%{
+static void $jswrapper(JSObjectRef thisObject)
+{
+  SwigPrivData* t = (SwigPrivData*) JSObjectGetPrivate(thisObject);
+  if(t) {
+    if (t->swigCMemOwn) {
+      free (($jstype)t->swigCObject);
+    }
+    JSObjectSetPrivate(thisObject, NULL);
+    free(t);
+  }
+}
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_dtor:  template for a destructor wrapper
+ *   - $jsmangledname:  mangled class name
+ *   - $jstype:         class type
+ *   - ${destructor_action}: The custom destructor action to invoke.
+ * ----------------------------------------------------------------------------- */
+%fragment ("js_dtoroverride", "templates")
+%{
+static void $jswrapper(JSObjectRef thisObject)
+{
+  SwigPrivData* t = (SwigPrivData*) JSObjectGetPrivate(thisObject);
+  if(t) {
+    if (t->swigCMemOwn) {
+      $jstype arg1 = ($jstype)t->swigCObject;
+      ${destructor_action}
+    }
+    /* remove the private data to make sure that it isn't accessed elsewhere */
+    JSObjectSetPrivate(thisObject, NULL);
+    free(t);
+  }
+}
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_getter:  template for getter function wrappers
+ *   - $jswrapper:  wrapper function name
+ *   - $jslocals:   locals part of wrapper
+ *   - $jscode:     code part of wrapper
+ * ----------------------------------------------------------------------------- */
+%fragment ("js_getter", "templates")
+%{
+static JSValueRef $jswrapper(JSContextRef context, JSObjectRef thisObject, JSStringRef propertyName, JSValueRef* exception)
+{
+    $jslocals
+    JSValueRef jsresult;
+
+    $jscode
+    return jsresult;
+
+    goto fail;
+    fail:
+    return JSValueMakeUndefined(context);
+}
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_setter:  template for setter function wrappers
+ *   - $jswrapper:  wrapper function name
+ *   - $jslocals:   locals part of wrapper
+ *   - $jscode:     code part of wrapper
+ * ----------------------------------------------------------------------------- */
+%fragment ("js_setter", "templates")
+%{
+static bool $jswrapper(JSContextRef context, JSObjectRef thisObject, JSStringRef propertyName, JSValueRef value, JSValueRef* exception)
+{
+    $jslocals
+    $jscode
+
+    return true;
+
+    goto fail;
+    fail:
+    return false;
+}
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_function:  template for function wrappers
+ *   - $jswrapper:  wrapper function name
+ *   - $jslocals:   locals part of wrapper
+ *   - $jscode:     code part of wrapper
+ * ----------------------------------------------------------------------------- */
+%fragment ("js_function", "templates")
+%{
+static JSValueRef $jswrapper(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argc, const JSValueRef argv[], JSValueRef* exception)
+{
+  $jslocals
+  JSValueRef jsresult;
+
+  if(argc != $jsargcount) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for $jswrapper.");
+
+  $jscode
+  return jsresult;
+
+  goto fail;
+  fail:
+  return JSValueMakeUndefined(context);
+}
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_function_dispatcher:  template for a function dispatcher for overloaded functions
+ *   - $jswrapper:  wrapper function name
+ *   - $jsname:     name of the wrapped function
+ *   - $jslocals:   locals part of wrapper
+ *   - $jscode:     code part of wrapper
+ * ----------------------------------------------------------------------------- */
+%fragment ("js_function_dispatcher", "templates")
+%{
+static JSValueRef $jswrapper(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argc, const JSValueRef argv[], JSValueRef* exception)
+{
+  $jslocals
+  JSValueRef jsresult;
+  int res;
+  $jscode
+
+  SWIG_exception_fail(SWIG_ERROR, "Illegal arguments for function $jsname.");
+  return jsresult;
+
+  goto fail;
+  fail:
+  return JSValueMakeUndefined(context);
+}
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_overloaded_function:  template for a overloaded function
+ *   - $jswrapper:  wrapper function name
+ *   - $jslocals:   locals part of wrapper
+ *   - $jscode:     code part of wrapper
+ * ----------------------------------------------------------------------------- */
+%fragment ("js_overloaded_function", "templates")
+%{
+static int $jswrapper(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argc, const JSValueRef argv[], JSValueRef* exception, JSValueRef* p_result)
+{
+  $jslocals
+  JSValueRef jsresult;
+
+  if(argc != $jsargcount) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for $jswrapper.");
+
+  $jscode
+  *p_result = jsresult;
+  return SWIG_OK;
+
+  goto fail;
+  fail:
+  return SWIG_TypeError;
+}
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_function_dispatch_case:  template for a case used in the function dispatcher
+ *   - $jswrapper:  wrapper function name
+ *   - $jsargcount: number of arguments of overloaded function
+ *   - $jscode:     code part of wrapper
+ * ----------------------------------------------------------------------------- */
+%fragment ("js_function_dispatch_case", "templates")
+%{
+  if(argc == $jsargcount) {
+     res = $jswrapper(context, function, thisObject, argc, argv, exception, &jsresult);
+     if(res == SWIG_OK) { *exception = 0; return jsresult; }
+  }
+%}
+
+/* -----------------------------------------------------------------------------
+ * jsc_variable_declaration:  template for a variable table entry
+ *   - $jsname:       name of the variable
+ *   - $jsgetter:     wrapper of getter function
+ *   - $jssetter:     wrapper of setter function
+ * ----------------------------------------------------------------------------- */
+%fragment ("jsc_variable_declaration", "templates")
+%{
+  {"$jsname", $jsgetter, $jssetter, kJSPropertyAttributeNone},
+%}
+
+
+/* -----------------------------------------------------------------------------
+ * jsc_function_declaration:  template for a function table entry
+ *   - $jsname:       name of the variable
+ *   - $jswrapper:    wrapper function
+ * ----------------------------------------------------------------------------- */
+%fragment ("jsc_function_declaration", "templates")
+%{
+  {"$jsname", $jswrapper, kJSPropertyAttributeNone},
+%}
+
+/* -----------------------------------------------------------------------------
+ * jsc_classtemplate_declaration:  template for a namespace declaration
+ *   - $jsmangledname:      mangled class name
+ * ----------------------------------------------------------------------------- */
+%fragment ("jsc_class_declaration", "templates")
+%{
+static JSClassDefinition $jsmangledname_classDefinition;
+
+static JSClassDefinition $jsmangledname_objectDefinition;
+
+static JSClassRef $jsmangledname_classRef;
+%}
+
+/* -----------------------------------------------------------------------------
+ * jsc_class_tables:  template for a namespace declaration
+ *   - $jsmangledname:            mangled class name
+ *   - $jsstaticclassvariables:   list of static variable entries
+ *   - $jsstaticclassfunctions:   list of static function entries
+ *   - $jsclassvariables:         list of member variable entries
+ *   - $jsclassfunctions:         list of member function entries
+ * ----------------------------------------------------------------------------- */
+%fragment ("jsc_class_tables", "templates")
+%{
+static JSStaticValue $jsmangledname_staticValues[] = {
+  $jsstaticclassvariables
+  { 0, 0, 0, 0 }
+};
+
+static JSStaticFunction $jsmangledname_staticFunctions[] = {
+  $jsstaticclassfunctions
+  { 0, 0, 0 }
+};
+
+static JSStaticValue $jsmangledname_values[] = {
+  $jsclassvariables
+  { 0, 0, 0, 0 }
+};
+
+static JSStaticFunction $jsmangledname_functions[] = {
+  $jsclassfunctions
+  { 0, 0, 0 }
+};
+%}
+
+/* -----------------------------------------------------------------------------
+ * jsc_define_class_template:  template for defining a class template
+ *   - $jsmangledname:            mangled class name
+ *   - $jsmangledtype:            mangled class type
+ *   - $jsctor:                   wrapper of ctor
+ *   - $jsbaseclass:              mangled name of base class
+ * ----------------------------------------------------------------------------- */
+%fragment ("jsc_class_definition", "templates")
+%{
+  $jsmangledname_classDefinition.staticFunctions = $jsmangledname_staticFunctions;
+  $jsmangledname_classDefinition.staticValues = $jsmangledname_staticValues;
+  $jsmangledname_classDefinition.callAsConstructor = $jsctor;
+  $jsmangledname_objectDefinition.finalize = $jsdtor;
+  $jsmangledname_objectDefinition.staticValues = $jsmangledname_values;
+  $jsmangledname_objectDefinition.staticFunctions = $jsmangledname_functions;
+  $jsclass_inheritance
+  $jsmangledname_classRef = JSClassCreate(&$jsmangledname_objectDefinition);
+  SWIGTYPE_$jsmangledtype->clientdata = $jsmangledname_classRef;
+%}
+
+%fragment ("jsc_class_inherit", templates)
+%{
+    if (SWIGTYPE_p$jsbaseclassmangled != NULL) {
+      $jsmangledname_objectDefinition.parentClass = (JSClassRef) SWIGTYPE_p$jsbaseclassmangled->clientdata;
+    }
+%}
+
+%fragment ("jsc_class_noinherit", templates)
+%{
+    $jsmangledname_objectDefinition.parentClass = _SwigObject_classRef;
+%}
+
+
+/* -----------------------------------------------------------------------------
+ * jsc_register_class:  template for registration of a class
+ *   - $jsname:                   class name
+ *   - $jsmangledname:            mangled class name
+ *   - $jsnspace:                 mangled name of namespace
+ * ----------------------------------------------------------------------------- */
+%fragment ("jsc_class_registration", "templates")
+%{
+  JS_registerClass(context, $jsnspace_object, "$jsname", &$jsmangledname_classDefinition);
+%}
+
+
+/* -----------------------------------------------------------------------------
+ * jsc_nspace_declaration:  template for a namespace declaration
+ *   - $jsnspace:           mangled name of the namespace
+ *   - $jsglobalvariables:  list of variable entries
+ *   - $jsglobalfunctions:  list if fuction entries
+ * ----------------------------------------------------------------------------- */
+%fragment ("jsc_nspace_declaration", "templates")
+%{
+static JSStaticValue $jsnspace_values[] = {
+  $jsglobalvariables
+  { 0, 0, 0, 0 }
+};
+
+static JSStaticFunction $jsnspace_functions[] = {
+  $jsglobalfunctions
+  { 0, 0, 0 }
+};
+
+static JSClassDefinition $jsnspace_classDefinition;
+static JSObjectRef $jsmangledname_object;
+%}
+
+/* -----------------------------------------------------------------------------
+ * jsc_nspace_definition:  template for definition of a namespace object
+ *   - $jsmangledname:            mangled name of namespace
+ * ----------------------------------------------------------------------------- */
+%fragment ("jsc_nspace_definition", "templates")
+%{
+  $jsmangledname_classDefinition.staticFunctions = $jsmangledname_functions;
+  $jsmangledname_classDefinition.staticValues = $jsmangledname_values;
+  $jsmangledname_object = JSObjectMake(context, JSClassCreate(&$jsmangledname_classDefinition), NULL);
+%}
+
+/* -----------------------------------------------------------------------------
+ * jsc_nspace_registration:  template for registration of a namespace object
+ *   - $jsname:                   name of namespace
+ *   - $jsmangledname:            mangled name of namespace
+ *   - $jsparent:                 mangled name of parent namespace
+ * ----------------------------------------------------------------------------- */
+%fragment ("jsc_nspace_registration", "templates")
+%{
+  JS_registerNamespace(context, $jsmangledname_object, $jsparent_object, "$jsname");
+%}
diff --git a/share/swig/3.0.12/javascript/jsc/javascriptcomplex.swg b/share/swig/3.0.12/javascript/jsc/javascriptcomplex.swg
new file mode 100644
index 0000000..7be120b
--- /dev/null
+++ b/share/swig/3.0.12/javascript/jsc/javascriptcomplex.swg
@@ -0,0 +1,146 @@
+/*
+  Defines the As/From converters for double/float complex, you need to
+  provide complex Type, the Name you want to use in the converters,
+  the complex Constructor method, and the Real and Imag complex
+  accessor methods.
+
+  See the std_complex.i and ccomplex.i for concrete examples.
+*/
+
+/* the common from converter */
+%define %swig_fromcplx_conv(Type, Real, Imag)
+%fragment(SWIG_From_frag(Type),"header",
+          fragment=SWIG_From_frag(double))
+{
+SWIGINTERNINLINE JSObjectRef
+SWIG_From_dec(Type)(%ifcplusplus(const Type&, Type) c)
+{
+  JSValueRef vals[2];
+  vals[0] =  SWIG_From(double)(Real(c));
+  vals[1] =  SWIG_From(double)(Imag(c));
+  return JSObjectMakeArray(context, 2, vals, NULL);
+}
+}
+%enddef
+
+/* the double case */
+%define %swig_cplxdbl_conv(Type, Constructor, Real, Imag)
+%fragment(SWIG_AsVal_frag(Type),"header",
+	  fragment=SWIG_AsVal_frag(double))
+{
+SWIGINTERN int
+SWIG_AsVal_dec(Type) (JSValueRef o, Type* val)
+{
+  if (JSValueIsObject(context, o)) {
+    JSObjectRef array;
+    JSValueRef exception, js_re, js_im;
+    double re, im;
+    int res;
+    
+    exception = 0;
+    res = 0;
+
+    array = JSValueToObject(context, o, &exception);
+    if(exception != 0)
+      return SWIG_TypeError;
+    
+    js_re = JSObjectGetPropertyAtIndex(context, array, 0, &exception);
+    if(exception != 0)
+      return SWIG_TypeError;
+
+    js_im = JSObjectGetPropertyAtIndex(context, array, 1, &exception);
+    if(exception != 0)
+      return SWIG_TypeError;
+
+    res = SWIG_AsVal(double)(js_re, &re);
+    if(!SWIG_IsOK(res)) {
+      return SWIG_TypeError;
+    }
+    
+    res = SWIG_AsVal(double)(js_im, &im);
+    if(!SWIG_IsOK(res)) {
+      return SWIG_TypeError;
+    }
+    
+    if (val) *val = Constructor(re, im);
+    return SWIG_OK;
+  } else {
+    double d;
+    int res = SWIG_AddCast(SWIG_AsVal(double)(o, &d));
+    if (SWIG_IsOK(res)) {
+      if (val) *val = Constructor(d, 0.0);
+      return res;
+    }
+  }
+  return SWIG_TypeError;
+}
+}
+%swig_fromcplx_conv(Type, Real, Imag);
+%enddef
+
+/* the float case */
+%define %swig_cplxflt_conv(Type, Constructor, Real, Imag)
+%fragment(SWIG_AsVal_frag(Type),"header",
+          fragment=SWIG_AsVal_frag(float)) {
+SWIGINTERN int
+SWIG_AsVal_dec(Type)(JSValueRef o, Type *val)
+{
+  if (JSValueIsObject(context, o)) {
+    JSObjectRef array;
+    JSValueRef exception, js_re, js_im;
+    double re, im;
+    int res;
+    
+    exception = 0;
+    res = 0;
+
+    array = JSValueToObject(context, o, &exception);
+    if(exception != 0)
+      return SWIG_TypeError;
+    
+    js_re = JSObjectGetPropertyAtIndex(context, array, 0, &exception);
+    if(exception != 0)
+      return SWIG_TypeError;
+
+    js_im = JSObjectGetPropertyAtIndex(context, array, 1, &exception);
+    if(exception != 0)
+      return SWIG_TypeError;
+
+    res = SWIG_AsVal(double)(js_re, &re);
+    if(!SWIG_IsOK(res)) {
+      return SWIG_TypeError;
+    }
+    
+    res = SWIG_AsVal(double)(js_im, &im);
+    if(!SWIG_IsOK(res)) {
+      return SWIG_TypeError;
+    }
+
+    if ((-FLT_MAX <= re && re <= FLT_MAX) && (-FLT_MAX <= im && im <= FLT_MAX)) {
+      if (val) *val = Constructor(%numeric_cast(re, float),
+                                  %numeric_cast(im, float));
+      return SWIG_OK;
+    } else {
+      return SWIG_OverflowError;
+    }    
+  } else {
+    float re;
+    int res = SWIG_AddCast(SWIG_AsVal(float)(o, &re));
+    if (SWIG_IsOK(res)) {
+      if (val) *val = Constructor(re, 0.0);
+      return res;
+    }
+  }
+  return SWIG_TypeError;
+}
+}
+
+%swig_fromcplx_conv(Type, Real, Imag);
+%enddef
+
+#define %swig_cplxflt_convn(Type, Constructor, Real, Imag) \
+%swig_cplxflt_conv(Type, Constructor, Real, Imag)
+
+
+#define %swig_cplxdbl_convn(Type, Constructor, Real, Imag) \
+%swig_cplxdbl_conv(Type, Constructor, Real, Imag)
diff --git a/share/swig/3.0.12/javascript/jsc/javascriptfragments.swg b/share/swig/3.0.12/javascript/jsc/javascriptfragments.swg
new file mode 100644
index 0000000..4778bf0
--- /dev/null
+++ b/share/swig/3.0.12/javascript/jsc/javascriptfragments.swg
@@ -0,0 +1,23 @@
+/*
+
+  Create a file with this name, 'javascriptfragments.swg', in your working
+  directory and add all the %fragments you want to take precedence
+  over the default ones defined by swig.
+
+  For example, if you add:
+  
+  %fragment(SWIG_AsVal_frag(int),"header") {
+   SWIGINTERNINLINE int
+   SWIG_AsVal(int)(PyObject *obj, int *val)
+   { 
+     <your code here>;
+   }
+  }
+  
+  this will replace the code used to retrieve an integer value for all
+  the typemaps that need it, including:
+  
+    int, std::vector<int>, std::list<std::pair<int,int> >, etc.
+
+    
+*/
diff --git a/share/swig/3.0.12/javascript/jsc/javascripthelpers.swg b/share/swig/3.0.12/javascript/jsc/javascripthelpers.swg
new file mode 100644
index 0000000..4576543
--- /dev/null
+++ b/share/swig/3.0.12/javascript/jsc/javascripthelpers.swg
@@ -0,0 +1,69 @@
+%insert(wrapper) %{
+ 
+SWIGINTERN bool JS_registerClass(JSGlobalContextRef context, JSObjectRef parentObject,
+                             const char* className,
+                             JSClassDefinition* definition) {
+
+    JSStringRef js_className = JSStringCreateWithUTF8CString(className);
+    JSObjectRef classObject = JSObjectMake(context, JSClassCreate(definition), NULL);
+    JSObjectSetProperty(context, parentObject,
+                        js_className, classObject,
+                        kJSPropertyAttributeNone, NULL);
+    JSStringRelease(js_className);
+    
+    return true;
+}
+
+SWIGINTERN bool JS_registerNamespace(JSGlobalContextRef context, 
+                           JSObjectRef namespaceObj, JSObjectRef parentNamespace,
+                           const char* name)
+{
+    JSStringRef js_name = JSStringCreateWithUTF8CString(name);
+    JSObjectSetProperty(context, parentNamespace,
+                        js_name, namespaceObj,
+                        kJSPropertyAttributeNone, NULL);
+    JSStringRelease(js_name);
+    
+    return true;
+}
+
+
+SWIGINTERN bool JS_registerFunction(JSGlobalContextRef context, JSObjectRef object, 
+                        const char* functionName, JSObjectCallAsFunctionCallback callback)
+{
+    JSStringRef js_functionName = JSStringCreateWithUTF8CString(functionName);
+    JSObjectSetProperty(context, object, js_functionName,
+                        JSObjectMakeFunctionWithCallback(context, js_functionName, callback), 
+                        kJSPropertyAttributeNone, NULL);
+    JSStringRelease(js_functionName);
+    return true;
+}
+
+SWIGINTERN bool JS_veto_set_variable(JSContextRef context, JSObjectRef thisObject, JSStringRef propertyName, JSValueRef value, JSValueRef* exception)
+{
+    char buffer[256];
+    char msg[512];
+    int res;
+    
+    JSStringGetUTF8CString(propertyName, buffer, 256);
+    res = sprintf(msg, "Tried to write read-only variable: %s.", buffer);
+    
+    if(res<0) {
+      SWIG_exception(SWIG_ERROR, "Tried to write read-only variable.");
+    } else {
+      SWIG_exception(SWIG_ERROR, msg);
+    }
+fail:    
+    return false;
+}
+
+SWIGINTERN JSValueRef JS_CharPtrToJSValue(JSContextRef context, char* cstr) {
+  JSValueRef val;
+  
+  JSStringRef jsstring = JSStringCreateWithUTF8CString((char*) cstr);
+  val = JSValueMakeString(context, jsstring);
+  JSStringRelease(jsstring);
+
+  return val;
+}
+%}
diff --git a/share/swig/3.0.12/javascript/jsc/javascriptinit.swg b/share/swig/3.0.12/javascript/jsc/javascriptinit.swg
new file mode 100644
index 0000000..a32ba33
--- /dev/null
+++ b/share/swig/3.0.12/javascript/jsc/javascriptinit.swg
@@ -0,0 +1,67 @@
+%insert(init) %{
+SWIGRUNTIME void
+SWIG_JSC_SetModule(swig_module_info *swig_module) {}
+
+SWIGRUNTIME swig_module_info *
+SWIG_JSC_GetModule(void) {
+  return 0;
+}
+
+#define SWIG_GetModule(clientdata)                SWIG_JSC_GetModule()
+#define SWIG_SetModule(clientdata, pointer)       SWIG_JSC_SetModule(pointer)
+%}
+
+%insert(init) "swiginit.swg"
+
+%fragment ("js_initializer_define", "templates") %{
+#define SWIGJSC_INIT $jsname_initialize
+%}
+
+// Open the initializer function
+%insert(init)
+%{
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+bool SWIGJSC_INIT (JSGlobalContextRef context, JSObjectRef *exports) {
+    SWIG_InitializeModule(0);
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_initializer:  template for the module initializer function
+ *   - $jsname:                   module name
+ *   - $jscreatenamespaces:       part with code for creating namespace objects
+ *   - $jscreateclasses:          part with code for creating classes
+ *   - $jsregisternamespaces:     part with code for registration of namespaces
+ * ----------------------------------------------------------------------------- */
+%fragment ("js_initializer", "templates") %{
+    /* Initialize the base swig type object */
+    _SwigObject_objectDefinition.staticFunctions = _SwigObject_functions;
+    _SwigObject_objectDefinition.staticValues = _SwigObject_values;
+    _SwigObject_classRef = JSClassCreate(&_SwigObject_objectDefinition);
+
+    /* Initialize the PackedData class */
+    _SwigPackedData_objectDefinition.staticFunctions = _SwigPackedData_functions;
+    _SwigPackedData_objectDefinition.staticValues = _SwigPackedData_values;
+    _SwigPackedData_objectDefinition.finalize = _wrap_SwigPackedData_delete;
+    _SwigPackedData_classRef = JSClassCreate(&_SwigPackedData_objectDefinition);
+
+    /* Create objects for namespaces */
+    $jscreatenamespaces
+
+    /* Register classes */
+    $jsregisterclasses
+
+    /* Register namespaces */
+    $jsregisternamespaces
+
+    *exports = exports_object;
+
+    return true;
+}
+#ifdef __cplusplus
+}
+#endif
+%}
diff --git a/share/swig/3.0.12/javascript/jsc/javascriptkw.swg b/share/swig/3.0.12/javascript/jsc/javascriptkw.swg
new file mode 100644
index 0000000..c3c1183
--- /dev/null
+++ b/share/swig/3.0.12/javascript/jsc/javascriptkw.swg
@@ -0,0 +1,40 @@
+#ifndef JAVASCRIPT_JAVASCRIPTKW_SWG_
+#define JAVASCRIPT_JAVASCRIPTKW_SWG_
+
+/* Warnings for Java keywords */
+#define JAVASCRIPTKW(x) %keywordwarn("'" `x` "' is a javascript keyword, renaming to '_"`x`"'",rename="_%s")  `x`
+
+/* Taken from https://developer.mozilla.org/En/Core_JavaScript_1.5_Reference/Reserved_Words */
+
+JAVASCRIPTKW(break);
+JAVASCRIPTKW(case);
+JAVASCRIPTKW(catch);
+JAVASCRIPTKW(continue);
+JAVASCRIPTKW(default);
+JAVASCRIPTKW(delete);
+JAVASCRIPTKW(do);
+JAVASCRIPTKW(else);
+JAVASCRIPTKW(finally);
+JAVASCRIPTKW(for);
+JAVASCRIPTKW(function);
+JAVASCRIPTKW(if);
+JAVASCRIPTKW(in);
+JAVASCRIPTKW(instanceof);
+JAVASCRIPTKW(new);
+JAVASCRIPTKW(return);
+JAVASCRIPTKW(switch);
+JAVASCRIPTKW(this);
+JAVASCRIPTKW(throw);
+JAVASCRIPTKW(try);
+JAVASCRIPTKW(typeof);
+JAVASCRIPTKW(var);
+JAVASCRIPTKW(void);
+JAVASCRIPTKW(while);
+JAVASCRIPTKW(with);
+
+/* others bad names if any*/
+// for example %namewarn("321:clone() is a javascript bad method name") *::clone();
+
+#undef JAVASCRIPTKW
+
+#endif //JAVASCRIPT_JAVASCRIPTKW_SWG_
diff --git a/share/swig/3.0.12/javascript/jsc/javascriptprimtypes.swg b/share/swig/3.0.12/javascript/jsc/javascriptprimtypes.swg
new file mode 100644
index 0000000..20d575d
--- /dev/null
+++ b/share/swig/3.0.12/javascript/jsc/javascriptprimtypes.swg
@@ -0,0 +1,192 @@
+/* ------------------------------------------------------------
+ * Primitive Types
+ * ------------------------------------------------------------ */
+
+/* boolean */
+
+%fragment(SWIG_From_frag(bool),"header") {
+SWIGINTERNINLINE
+JSValueRef SWIG_From_dec(bool)(bool value)
+{
+  return JSValueMakeBoolean(context, value);
+}
+}
+
+%fragment(SWIG_AsVal_frag(bool),"header",
+          fragment=SWIG_AsVal_frag(long)) {
+SWIGINTERN
+int SWIG_AsVal_dec(bool)(JSValueRef obj, bool *val)
+{
+  if(!JSValueIsBoolean(context, obj)) {
+    return SWIG_ERROR;
+  }
+  if (val) *val = JSValueToBoolean(context, obj);
+  return SWIG_OK;
+}
+}
+
+/* int */
+
+%fragment(SWIG_From_frag(int),"header") {
+SWIGINTERNINLINE JSValueRef
+  SWIG_From_dec(int)(int value)
+{
+  return JSValueMakeNumber(context, value);
+}
+}
+
+/* long */
+
+%fragment(SWIG_From_frag(long),"header") {
+SWIGINTERNINLINE JSValueRef
+SWIG_From_dec(long)(long value)
+{
+  return JSValueMakeNumber(context, value);
+}
+}
+
+%fragment(SWIG_AsVal_frag(long),"header",
+          fragment="SWIG_CanCastAsInteger") {
+SWIGINTERN int
+SWIG_AsVal_dec(long)(JSValueRef obj, long* val)
+{
+  if (!JSValueIsNumber(context, obj)) {
+    return SWIG_TypeError;
+  }
+  if(val) *val = (long) JSValueToNumber(context, obj, NULL);
+
+  return SWIG_OK;
+}
+}
+
+/* unsigned long */
+
+%fragment(SWIG_From_frag(unsigned long),"header",
+          fragment=SWIG_From_frag(long)) {
+SWIGINTERNINLINE JSValueRef
+SWIG_From_dec(unsigned long)(unsigned long value)
+{
+  return (value > LONG_MAX) ?
+    JSValueMakeNumber(context, value) : JSValueMakeNumber(context, %numeric_cast(value,long));
+}
+}
+
+%fragment(SWIG_AsVal_frag(unsigned long),"header",
+          fragment="SWIG_CanCastAsInteger") {
+SWIGINTERN int
+SWIG_AsVal_dec(unsigned long)(JSValueRef obj, unsigned long *val)
+{
+  long longVal;
+  if(!JSValueIsNumber(context, obj)) {
+    return SWIG_TypeError;
+  }
+
+  longVal = (long) JSValueToNumber(context, obj, NULL);
+
+  if(longVal < 0) {
+      return SWIG_OverflowError;
+  }
+
+  if(val) *val = longVal;
+
+  return SWIG_OK;
+}
+}
+
+/* long long */
+// Note: these are copied from 'long' and probably need fixing
+
+%fragment(SWIG_From_frag(long long),"header",
+    fragment=SWIG_From_frag(long),
+    fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERNINLINE JSValueRef
+SWIG_From_dec(long long)(long long value)
+{
+  return JSValueMakeNumber(context, value);
+}
+%#endif
+}
+
+%fragment(SWIG_AsVal_frag(long long),"header",
+    fragment=SWIG_AsVal_frag(long),
+    fragment="SWIG_CanCastAsInteger",
+    fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERN int
+SWIG_AsVal_dec(long long)(JSValueRef obj, long long* val)
+{
+  if (!JSValueIsNumber(context, obj)) {
+    return SWIG_TypeError;
+  }
+  if(val) *val = (long long) JSValueToNumber(context, obj, NULL);
+
+  return SWIG_OK;
+}
+%#endif
+}
+
+/* unsigned long long */
+// Note: these are copied from 'unsigned long' and probably need fixing
+
+%fragment(SWIG_From_frag(unsigned long long),"header",
+	  fragment=SWIG_From_frag(long long),
+	  fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERN JSValueRef
+SWIG_From_dec(unsigned long long)(unsigned long long value)
+{
+  return (value > LONG_MAX) ?
+    JSValueMakeNumber(context, value) : JSValueMakeNumber(context, %numeric_cast(value,long));
+}
+%#endif
+}
+
+%fragment(SWIG_AsVal_frag(unsigned long long),"header",
+    fragment=SWIG_AsVal_frag(unsigned long),
+    fragment="SWIG_CanCastAsInteger",
+   fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERN int
+SWIG_AsVal_dec(unsigned long long)(JSValueRef obj, unsigned long long *val)
+{
+  long long longVal;
+  if(!JSValueIsNumber(context, obj)) {
+    return SWIG_TypeError;
+  }
+
+  longVal = (unsigned long long) JSValueToNumber(context, obj, NULL);
+
+  if(longVal < 0) {
+      return SWIG_OverflowError;
+  }
+
+  if(val) *val = longVal;
+
+  return SWIG_OK;
+}
+%#endif
+}
+
+/* double */
+
+%fragment(SWIG_From_frag(double),"header") {
+SWIGINTERN JSValueRef
+SWIG_From_dec(double) (double val)
+{
+  return JSValueMakeNumber(context, val);
+}
+}
+
+%fragment(SWIG_AsVal_frag(double),"header") {
+SWIGINTERN int
+SWIG_AsVal_dec(double)(JSValueRef obj, double *val)
+{
+  if(!JSValueIsNumber(context, obj)) {
+    return SWIG_TypeError;
+  }
+  if(val) *val = JSValueToNumber(context, obj, NULL);
+
+  return SWIG_OK;
+}
+}
diff --git a/share/swig/3.0.12/javascript/jsc/javascriptrun.swg b/share/swig/3.0.12/javascript/jsc/javascriptrun.swg
new file mode 100644
index 0000000..30ee032
--- /dev/null
+++ b/share/swig/3.0.12/javascript/jsc/javascriptrun.swg
@@ -0,0 +1,334 @@
+/* ----------------------------------------------------------------------------
+ *  Errors and exceptions
+ *
+ * ---------------------------------------------------------------------------*/
+
+#define SWIG_Error(code, msg)     SWIG_JSC_exception(context, exception, code, msg)
+#define SWIG_exception(code, msg) do { SWIG_JSC_exception(context, exception, code, msg); SWIG_fail; } while (0)
+#define SWIG_fail                 goto fail
+
+SWIGRUNTIME void SWIG_Javascript_Raise(JSContextRef context, JSValueRef *exception, const char* type) {
+  JSStringRef message = JSStringCreateWithUTF8CString(type);
+  JSValueRef error_arguments[1]; 
+  JSObjectRef exception_object;
+  JSValueRef exception_value;
+  exception_value = JSValueMakeString(context, message);
+  /* Converting the result to an object will let JavascriptCore add 
+     "sourceURL" (file) and "line" (number) and "message" to the exception,
+     instead of just returning a raw string. This is extremely important for debugging your errors.
+     Using JSObjectMakeError is better than JSValueToObject because the latter only populates
+     "sourceURL" and "line", but not "message" or any others I don't know about.
+   */
+  error_arguments[0] = exception_value;
+  exception_object = JSObjectMakeError(context, 1, error_arguments, NULL);
+
+  /* Return the exception_object */
+  *exception = exception_object;
+
+  JSStringRelease(message);
+}
+
+SWIGRUNTIME void SWIG_JSC_exception(JSContextRef context, JSValueRef *exception, int code, const char* msg) {
+  SWIG_Javascript_Raise(context, exception, msg);
+}
+
+/* ----------------------------------------------------------------------------
+ *  The parent class of all Proxies
+ *
+ * ---------------------------------------------------------------------------*/
+
+typedef struct {
+  bool swigCMemOwn;
+  void *swigCObject;
+  swig_type_info *info;
+} SwigPrivData;
+
+SWIGRUNTIME JSValueRef _wrap_SwigObject_disown(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argc, const JSValueRef argv[], JSValueRef* exception)
+{
+  JSValueRef jsresult;
+
+  JSObjectRef obj = JSValueToObject(context, thisObject, NULL);
+  SwigPrivData *cdata = (SwigPrivData *) JSObjectGetPrivate(obj);
+
+  cdata->swigCMemOwn = false;
+
+  jsresult = JSValueMakeUndefined(context);
+  return jsresult;
+}
+
+SWIGRUNTIME JSValueRef _wrap_SwigObject_getCPtr(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argc, const JSValueRef argv[], JSValueRef* exception)
+{
+  JSValueRef jsresult;
+  long result;
+
+  JSObjectRef obj = JSValueToObject(context, thisObject, NULL);
+  SwigPrivData *cdata = (SwigPrivData*) JSObjectGetPrivate(obj);
+
+  result = (long) cdata->swigCObject;
+  jsresult = JSValueMakeNumber(context, result);
+
+  return jsresult;
+}
+
+SWIGRUNTIME JSValueRef _wrap_SwigObject_equals(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argc, const JSValueRef argv[], JSValueRef* exception)
+{
+  JSValueRef jsresult;
+  bool result;
+
+  JSObjectRef obj = JSValueToObject(context, thisObject, NULL);
+  SwigPrivData *cdata = (SwigPrivData*) JSObjectGetPrivate(obj);
+
+  JSObjectRef obj2 = JSValueToObject(context, argv[0], NULL);
+  SwigPrivData *cdata2 = (SwigPrivData*) JSObjectGetPrivate(obj2);
+
+  result = (cdata->swigCObject == cdata2->swigCObject);
+  jsresult = JSValueMakeBoolean(context, result);
+
+  return jsresult;
+}
+
+SWIGRUNTIME JSStaticValue _SwigObject_values[] = {
+  {
+    0, 0, 0, 0
+  }
+};
+
+SWIGRUNTIME JSStaticFunction _SwigObject_functions[] = {
+  {
+    "disown",_wrap_SwigObject_disown, kJSPropertyAttributeNone
+  },
+  {
+    "equals",_wrap_SwigObject_equals, kJSPropertyAttributeNone
+  },
+  {
+    "getCPtr",_wrap_SwigObject_getCPtr, kJSPropertyAttributeNone
+  },
+  {
+    0, 0, 0
+  }
+};
+
+SWIGRUNTIME JSClassDefinition _SwigObject_objectDefinition;
+
+SWIGRUNTIME JSClassRef _SwigObject_classRef;
+
+
+SWIGRUNTIME int SWIG_JSC_ConvertInstancePtr(JSContextRef context, JSObjectRef objRef, void** ptr, swig_type_info *info, int flags) {
+  SwigPrivData *cdata;
+
+  cdata = (SwigPrivData *) JSObjectGetPrivate(objRef);
+  if(cdata == NULL) {
+    return SWIG_ERROR;
+  }
+  if(cdata->info != info) {
+    bool type_valid = false;
+    swig_cast_info *t = info->cast;
+    while(t != NULL) {
+      if(t->type == cdata->info) {
+        type_valid = true;
+        break;
+      }
+      t = t->next;
+    }
+    if(!type_valid) {
+      return SWIG_TypeError;
+    }
+  }
+
+  *ptr = cdata->swigCObject;
+
+  if(flags & SWIG_POINTER_DISOWN) {
+    cdata->swigCMemOwn = false;
+  }
+
+  return SWIG_OK;
+}
+
+SWIGRUNTIME int SWIG_JSC_ConvertPtr(JSContextRef context, JSValueRef valRef, void** ptr, swig_type_info *info, int flags) {
+  JSObjectRef objRef;
+
+  /* special case: JavaScript null => C NULL pointer */
+  if(JSValueIsNull(context, valRef)) {
+    *ptr=0;
+    return SWIG_OK;
+  }
+
+  if(!JSValueIsObject(context, valRef)) {
+    return SWIG_TypeError;
+  }
+
+  objRef = JSValueToObject(context, valRef, NULL);
+  if(objRef == NULL) {
+    return SWIG_ERROR;
+  }
+
+  return SWIG_JSC_ConvertInstancePtr(context, objRef, ptr, info, flags);
+}
+
+SWIGRUNTIME JSObjectRef SWIG_JSC_NewPointerObj(JSContextRef context, void *ptr, swig_type_info *info, int flags) {
+  JSClassRef classRef;
+  JSObjectRef result;
+  SwigPrivData *cdata;
+
+  if (ptr == NULL) {
+    // HACK: it is not possible to use JSValueToObject (causing seg-fault)
+    // This static cast turned out to be a workaround
+    // In future, we should change the interface of this method
+    // to return JSValueRef instead of JSObjectRef.
+    return (JSObjectRef) JSValueMakeNull(context);
+  }
+
+  if(info->clientdata == NULL) {
+    classRef = _SwigObject_classRef;
+  } else {
+    classRef = (JSClassRef) info->clientdata;
+  }
+
+  result = JSObjectMake(context, classRef, NULL);
+
+  cdata = (SwigPrivData*) malloc(sizeof(SwigPrivData));
+  cdata->swigCObject = ptr;
+  cdata->swigCMemOwn = (flags & SWIG_POINTER_OWN) ? 1 : 0;
+  cdata->info = info;
+
+  JSObjectSetPrivate(result, cdata);
+
+  return result;
+}
+
+#define SWIG_ConvertPtr(obj, ptr, info, flags)    SWIG_JSC_ConvertPtr(context, obj, ptr, info, flags)
+#define SWIG_NewPointerObj(ptr, info, flags)      SWIG_JSC_NewPointerObj(context, ptr, info, flags)
+
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_JSC_ConvertInstancePtr(context, obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(thisvalue, type, flags)     SWIG_JSC_NewPointerObj(context, thisvalue, type, flags)
+
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_JSC_ConvertPtr(context, obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_JSC_NewPointerObj(context, ptr, type, 0)
+
+/* ----------------------------------------------------------------------------
+ *  A class for packed data
+ *
+ * ---------------------------------------------------------------------------*/
+
+typedef struct {
+  void *data;
+  size_t size;
+  swig_type_info *type;
+} SwigPackedData;
+
+SWIGRUNTIME JSStaticValue _SwigPackedData_values[] = {
+  {
+    0, 0, 0, 0
+  }
+};
+SWIGRUNTIME JSStaticFunction _SwigPackedData_functions[] = {
+  {
+    0, 0, 0
+  }
+};
+SWIGRUNTIME JSClassDefinition _SwigPackedData_objectDefinition;
+SWIGRUNTIME JSClassRef _SwigPackedData_classRef;
+
+SWIGRUNTIMEINLINE
+int SwigJSCPacked_Check(JSContextRef context, JSValueRef valRef) {
+  return JSValueIsObjectOfClass(context, valRef, _SwigPackedData_classRef);
+}
+
+SWIGRUNTIME
+swig_type_info* SwigJSCPacked_UnpackData(JSContextRef context, JSValueRef valRef, void *ptr, size_t size) {
+  if (SwigJSCPacked_Check(context, valRef)) {
+    JSObjectRef objRef = JSValueToObject(context, valRef, NULL);
+    SwigPackedData *sobj = (SwigPackedData *) JSObjectGetPrivate(objRef);
+    if (sobj->size != size) return 0;
+    memcpy(ptr, sobj->data, size);
+    return sobj->type;
+  } else {
+    return 0;
+  }
+}
+
+SWIGRUNTIME
+int SWIG_JSC_ConvertPacked(JSContextRef context, JSValueRef valRef, void *ptr, size_t sz, swig_type_info *ty) {
+  swig_type_info *to = SwigJSCPacked_UnpackData(context, valRef, ptr, sz);
+  if (!to) return SWIG_ERROR;
+  if (ty) {
+    if (to != ty) {
+      /* check type cast? */
+      swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
+      if (!tc) return SWIG_ERROR;
+    }
+  }
+  return SWIG_OK;
+}
+
+SWIGRUNTIME
+JSValueRef SWIG_JSC_NewPackedObj(JSContextRef context, void *data, size_t size, swig_type_info *type) {
+
+  JSClassRef classRef = _SwigObject_classRef;
+  JSObjectRef result = JSObjectMake(context, classRef, NULL);
+
+  SwigPackedData* cdata = (SwigPackedData*) malloc(sizeof(SwigPackedData));
+  cdata->data = data;
+  cdata->size = size;
+  cdata->type = type;
+
+  JSObjectSetPrivate(result, cdata);
+
+  return result;
+}
+
+/*  SwigPackedData wrappers  */
+SWIGRUNTIME
+void _wrap_SwigPackedData_delete(JSObjectRef obj)
+{
+  SwigPackedData* cdata = (SwigPackedData*) JSObjectGetPrivate(obj);
+  if (cdata) {
+    free(cdata->data);
+  }
+}
+
+/* for C++ member pointers, ie, member methods */
+
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_JSC_ConvertPacked(context, obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_JSC_NewPackedObj(context, ptr, sz, type)
+
+
+/* ---------------------------------------------------------------------------
+ * Support for IN/OUTPUT typemaps (see Lib/typemaps/inoutlist.swg)
+ *
+ * ---------------------------------------------------------------------------*/
+SWIGRUNTIME
+unsigned int SWIGJSC_ArrayLength(JSContextRef context, JSObjectRef arr) {
+  static JSStringRef LENGTH = 0;
+  JSValueRef exception = NULL;
+  JSValueRef js_length;
+  double length;
+
+  if (LENGTH == 0) {
+    LENGTH = JSStringCreateWithUTF8CString("length");
+  }
+
+  js_length = JSObjectGetProperty(context, arr, LENGTH, &exception);
+  if (exception == 0 && JSValueIsNumber(context, js_length)) {
+    length = JSValueToNumber(context, js_length, 0);
+    return (unsigned int) length;
+  } else {
+    return 0;
+  }
+}
+
+SWIGRUNTIME
+JSValueRef SWIGJSC_AppendOutput(JSContextRef context, JSValueRef value, JSValueRef obj) {
+  JSObjectRef arr;
+  unsigned int length;
+
+  if (JSValueIsUndefined(context, value)) {
+    arr = JSObjectMakeArray(context, 0, 0, 0);
+  } else {
+    arr = JSValueToObject(context, value, 0);
+  }
+
+  length = SWIGJSC_ArrayLength(context, arr);
+  JSObjectSetPropertyAtIndex(context, arr, length, obj, 0);
+  return arr;
+}
diff --git a/share/swig/3.0.12/javascript/jsc/javascriptruntime.swg b/share/swig/3.0.12/javascript/jsc/javascriptruntime.swg
new file mode 100644
index 0000000..8f83908
--- /dev/null
+++ b/share/swig/3.0.12/javascript/jsc/javascriptruntime.swg
@@ -0,0 +1,19 @@
+/* -----------------------------------------------------------------------------
+ * javascriptruntime.swg
+ *
+ * Javascript support code
+ * ----------------------------------------------------------------------------- */
+
+%insert(runtime) %{
+#include <JavaScriptCore/JavaScript.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <limits.h>
+%}
+
+%insert(runtime) "swigrun.swg";         /* SWIG API */
+%insert(runtime) "swigerrors.swg";      /* SWIG errors */
+
+%insert(runtime) "javascriptrun.swg";      /* SWIG errors */
diff --git a/share/swig/3.0.12/javascript/jsc/javascriptstrings.swg b/share/swig/3.0.12/javascript/jsc/javascriptstrings.swg
new file mode 100644
index 0000000..55c8e4b
--- /dev/null
+++ b/share/swig/3.0.12/javascript/jsc/javascriptstrings.swg
@@ -0,0 +1,185 @@
+/* ------------------------------------------------------------
+ *  utility methods for char strings
+ * ------------------------------------------------------------ */
+%fragment("SWIG_AsCharPtrAndSize","header",fragment="SWIG_pchar_descriptor") {
+SWIGINTERN int
+SWIG_JSC_AsCharPtrAndSize(JSContextRef context, JSValueRef valRef, char** cptr, size_t* psize, int *alloc)
+{
+  if(JSValueIsString(context, valRef)) {
+    JSStringRef js_str = JSValueToStringCopy(context, valRef, NULL);
+    size_t len = JSStringGetMaximumUTF8CStringSize(js_str);
+    char* cstr = (char*) %new_array(len, char);
+    /* JSStringGetUTF8CString returns the length including 0-terminator */
+    len = JSStringGetUTF8CString(js_str, cstr, len);
+
+    if(alloc) *alloc = SWIG_NEWOBJ;
+    if(psize) *psize = len;
+    if(cptr) *cptr = cstr;
+
+    return SWIG_OK;
+  } else {
+    if(JSValueIsObject(context, valRef)) {
+      JSObjectRef obj = JSValueToObject(context, valRef, NULL);
+      // try if the object is a wrapped char[]
+      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+      if (pchar_descriptor) {
+        void* vptr = 0;
+        if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
+          if (cptr) *cptr = (char *) vptr;
+          if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
+          if (alloc) *alloc = SWIG_OLDOBJ;
+          return SWIG_OK;
+        }
+      }
+      return SWIG_TypeError;
+    } else {
+      return SWIG_TypeError;
+    }
+  }
+}
+}
+
+%fragment("SWIG_FromCharPtrAndSize","header",fragment="SWIG_pchar_descriptor") {
+SWIGINTERNINLINE JSValueRef
+SWIG_JSC_FromCharPtrAndSize(JSContextRef context, const char* carray, size_t size)
+{
+  if (carray) {
+    if (size > INT_MAX) {
+      // TODO: handle extra long strings
+      //swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+      //return pchar_descriptor ?
+      //  SWIG_InternalNewPointerObj(%const_cast(carray,char *), pchar_descriptor, 0) : SWIG_Py_Void();
+      return JSValueMakeUndefined(context);
+    } else {
+      JSStringRef jsstring;
+      JSValueRef result;
+      if(size < 2) {
+        char c[2];
+        int i;
+        for(i=0;i<size;++i) {
+          c[i] = carray[i];
+        }
+        c[size] = 0;
+        jsstring = JSStringCreateWithUTF8CString(c);
+      } else {
+        jsstring = JSStringCreateWithUTF8CString(carray);
+      }
+      result = JSValueMakeString(context, jsstring);
+      JSStringRelease(jsstring);
+      return result;
+    }
+  } else {
+    return JSValueMakeUndefined(context);
+  }
+}
+}
+
+%define %_typemap2_string(StringCode, CharCode,
+			 Char, CharName,
+			 SWIG_AsCharPtrAndSize,
+			 SWIG_FromCharPtrAndSize,
+			 SWIG_CharPtrLen,
+       SWIG_CharBufLen,
+			 SWIG_NewCopyCharArray,
+			 SWIG_DeleteCharArray,
+			 FragLimits, CHAR_MIN, CHAR_MAX)
+
+%fragment("SWIG_From"#CharName"Ptr","header",fragment=#SWIG_FromCharPtrAndSize) {
+SWIGINTERNINLINE SWIG_Object
+SWIG_JSC_From##CharName##Ptr(JSContextRef context, const Char *cptr)
+{
+  return SWIG_JSC_FromCharPtrAndSize(context, cptr, (cptr ? SWIG_CharPtrLen(cptr) : 0));
+}
+}
+
+%fragment("SWIG_From"#CharName"Array","header",fragment=#SWIG_FromCharPtrAndSize) {
+SWIGINTERNINLINE SWIG_Object
+SWIG_JSC_From##CharName##Array(JSContextRef context, const Char *cptr, size_t size)
+{
+  return SWIG_JSC_FromCharPtrAndSize(context, cptr, size);
+}
+}
+
+%fragment("SWIG_As" #CharName "Ptr","header",fragment=#SWIG_AsCharPtrAndSize) {
+%define_as(SWIG_As##CharName##Ptr(obj, val, alloc), SWIG_JSC_AsCharPtrAndSize(context, obj, val, NULL, alloc))
+}
+
+%fragment("SWIG_As" #CharName "Array","header",fragment=#SWIG_AsCharPtrAndSize) {
+SWIGINTERN int
+SWIG_JSC_As##CharName##Array(JSContextRef context, SWIG_Object obj, Char *val, size_t size)
+{
+  Char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
+  int res = SWIG_JSC_AsCharPtrAndSize(context, obj, &cptr, &csize, &alloc);
+  if (SWIG_IsOK(res)) {
+    if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
+    if (csize <= size) {
+      if (val) {
+        if (csize) memcpy(val, cptr, csize*sizeof(Char));
+        if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(Char));
+      }
+      if (alloc == SWIG_NEWOBJ) {
+        SWIG_DeleteCharArray(cptr);
+        res = SWIG_DelNewMask(res);
+      }
+      return res;
+    }
+    if (alloc == SWIG_NEWOBJ) SWIG_DeleteCharArray(cptr);
+  }
+  return SWIG_TypeError;
+}
+
+#define SWIG_As##CharName##Array(obj, val, size) SWIG_JSC_As##CharName##Array(context, obj, val, size)
+}
+
+/* Char */
+
+%fragment(SWIG_From_frag(Char),"header",fragment=#SWIG_FromCharPtrAndSize) {
+SWIGINTERNINLINE SWIG_Object
+SWIG_From_dec(Char)(Char c)
+{
+  return SWIG_JSC_FromCharPtrAndSize(context, &c,1);
+}
+}
+
+%fragment(SWIG_AsVal_frag(Char),"header",
+          fragment="SWIG_As"#CharName"Array",
+          fragment=FragLimits,
+          fragment=SWIG_AsVal_frag(long)) {
+SWIGINTERN int
+SWIG_AsVal_dec(Char)(SWIG_Object obj, Char *val)
+{
+  int res = SWIG_As##CharName##Array(obj, val, 1);
+  if (!SWIG_IsOK(res)) {
+    long v;
+    res = SWIG_AddCast(SWIG_AsVal(long)(obj, &v));
+    if (SWIG_IsOK(res)) {
+      if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
+        if (val) *val = %numeric_cast(v, Char);
+      } else {
+        res = SWIG_OverflowError;
+      }
+    }
+  }
+  return res;
+}
+}
+
+%_typemap_string(StringCode,
+                 Char,
+                 SWIG_AsCharPtrAndSize,
+                 SWIG_FromCharPtrAndSize,
+                 SWIG_CharPtrLen,
+                 SWIG_CharBufLen,
+                 SWIG_As##CharName##Ptr,
+                 SWIG_From##CharName##Ptr,
+                 SWIG_As##CharName##Array,
+                 SWIG_NewCopyCharArray,
+                 SWIG_DeleteCharArray)
+
+%enddef
+
+%insert(runtime) %{
+#define SWIG_AsCharPtrAndSize(val, cptr, psize, alloc)  SWIG_JSC_AsCharPtrAndSize(context, val, cptr, psize, alloc)
+#define SWIG_FromCharPtrAndSize(cptr, size)  SWIG_JSC_FromCharPtrAndSize(context, cptr, size)
+#define SWIG_FromCharPtr(cptr) SWIG_JSC_FromCharPtr(context, cptr)
+%}
diff --git a/share/swig/3.0.12/javascript/jsc/javascripttypemaps.swg b/share/swig/3.0.12/javascript/jsc/javascripttypemaps.swg
new file mode 100644
index 0000000..e8fbbec
--- /dev/null
+++ b/share/swig/3.0.12/javascript/jsc/javascripttypemaps.swg
@@ -0,0 +1,54 @@
+/* ------------------------------------------------------------
+ *  Typemap specializations for Javascript
+ * ------------------------------------------------------------ */
+
+/* ------------------------------------------------------------
+ *  Fragment section
+ * ------------------------------------------------------------ */
+
+/* These macros are necessary to provide an extra parameter
+   to SWIG_AsVal_dec functions (JSContextRef context).
+   They must be defined before including `typemaps/fragments.swg`
+*/
+#define SWIG_FROM_DECL_ARGS SWIG_JSC_FROM_DECL_ARGS
+#define SWIG_FROM_CALL_ARGS SWIG_JSC_FROM_CALL_ARGS
+#define SWIG_AS_DECL_ARGS SWIG_JSC_AS_DECL_ARGS
+#define SWIG_AS_CALL_ARGS SWIG_JSC_AS_CALL_ARGS
+
+/* Include fundamental fragemt definitions */
+%include <typemaps/fragments.swg>
+
+/* Look for user fragments file. */
+%include <javascriptfragments.swg>
+
+/* Javascript fragments for fundamental types */
+%include <javascriptprimtypes.swg>
+
+/* Javascript fragments for char* strings */
+%include <javascriptstrings.swg>
+
+/* ------------------------------------------------------------
+ *  Unified typemap section
+ * ------------------------------------------------------------ */
+
+#define SWIG_Object                     JSValueRef
+#define VOID_Object                     JSValueMakeUndefined(context)
+
+/* append output */
+#define SWIG_AppendOutput(result, obj) SWIGJSC_AppendOutput(context, result, obj)
+
+/* set constant */
+#define SWIG_SetConstant(name, obj)
+
+/* raise */
+#define SWIG_Raise(obj, type, desc)  SWIG_Javascript_Raise(context, exception, type)
+
+%insert("runtime") %{
+#define SWIG_JSC_FROM_DECL_ARGS(arg1)              (JSContextRef context, arg1)
+#define SWIG_JSC_FROM_CALL_ARGS(arg1)              (context, arg1)
+#define SWIG_JSC_AS_DECL_ARGS(arg1, arg2)          (JSContextRef context, arg1, arg2)
+#define SWIG_JSC_AS_CALL_ARGS(arg1, arg2)          (context, arg1, arg2)
+%}
+
+/* Include the unified typemap library */
+%include <typemaps/swigtypemaps.swg>
diff --git a/share/swig/2.0.11/lua/std_common.i b/share/swig/3.0.12/javascript/jsc/std_common.i
index cee11e8..cee11e8 100644
--- a/share/swig/2.0.11/lua/std_common.i
+++ b/share/swig/3.0.12/javascript/jsc/std_common.i
diff --git a/share/swig/3.0.12/javascript/jsc/std_complex.i b/share/swig/3.0.12/javascript/jsc/std_complex.i
new file mode 100644
index 0000000..088a4fe
--- /dev/null
+++ b/share/swig/3.0.12/javascript/jsc/std_complex.i
@@ -0,0 +1,19 @@
+/*
+ *  STD C++ complex typemaps
+ */
+
+%include <javascriptcomplex.swg>
+
+%{
+#include <complex> 
+%}
+
+/* defining the complex as/from converters */
+
+%swig_cplxdbl_convn(std::complex<double>, std::complex<double>, std::real, std::imag)
+%swig_cplxflt_convn(std::complex<float>,  std::complex<float>,  std::real, std::imag)
+
+/* defining the typemaps */
+
+%typemaps_primitive(%checkcode(CPLXDBL), std::complex<double>);
+%typemaps_primitive(%checkcode(CPLXFLT), std::complex<float>);
diff --git a/share/swig/2.0.11/lua/std_deque.i b/share/swig/3.0.12/javascript/jsc/std_deque.i
index cb98f6c..cb98f6c 100644
--- a/share/swig/2.0.11/lua/std_deque.i
+++ b/share/swig/3.0.12/javascript/jsc/std_deque.i
diff --git a/share/swig/2.0.11/octave/std_except.i b/share/swig/3.0.12/javascript/jsc/std_except.i
index af98428..af98428 100644
--- a/share/swig/2.0.11/octave/std_except.i
+++ b/share/swig/3.0.12/javascript/jsc/std_except.i
diff --git a/share/swig/2.0.11/perl5/std_map.i b/share/swig/3.0.12/javascript/jsc/std_map.i
index e7812f3..e7812f3 100644
--- a/share/swig/2.0.11/perl5/std_map.i
+++ b/share/swig/3.0.12/javascript/jsc/std_map.i
diff --git a/share/swig/2.0.11/ocaml/std_pair.i b/share/swig/3.0.12/javascript/jsc/std_pair.i
index fe45ee6..fe45ee6 100644
--- a/share/swig/2.0.11/ocaml/std_pair.i
+++ b/share/swig/3.0.12/javascript/jsc/std_pair.i
diff --git a/share/swig/2.0.11/octave/std_string.i b/share/swig/3.0.12/javascript/jsc/std_string.i
index dc1378a..dc1378a 100644
--- a/share/swig/2.0.11/octave/std_string.i
+++ b/share/swig/3.0.12/javascript/jsc/std_string.i
diff --git a/share/swig/3.0.12/javascript/jsc/std_vector.i b/share/swig/3.0.12/javascript/jsc/std_vector.i
new file mode 100644
index 0000000..971b426
--- /dev/null
+++ b/share/swig/3.0.12/javascript/jsc/std_vector.i
@@ -0,0 +1,85 @@
+/* -----------------------------------------------------------------------------
+ * std_vector.i
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.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 {
+            bool 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");
+            }
+        }
+    };
+}
+
+%define specialize_std_vector(T)
+#warning "specialize_std_vector - specialization for type T no longer needed"
+%enddef
+
diff --git a/share/swig/2.0.11/lua/stl.i b/share/swig/3.0.12/javascript/jsc/stl.i
index 04f8601..04f8601 100644
--- a/share/swig/2.0.11/lua/stl.i
+++ b/share/swig/3.0.12/javascript/jsc/stl.i
diff --git a/share/swig/3.0.12/javascript/jsc/typemaps.i b/share/swig/3.0.12/javascript/jsc/typemaps.i
new file mode 100644
index 0000000..d3d8afb
--- /dev/null
+++ b/share/swig/3.0.12/javascript/jsc/typemaps.i
@@ -0,0 +1,148 @@
+/* -----------------------------------------------------------------------------
+ * typemaps.i
+ *
+ * Pointer handling
+ * These mappings provide support for input/output arguments and common
+ * uses for C/C++ pointers.
+ * ----------------------------------------------------------------------------- */
+
+// 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
+         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 Python tuple.
+
+         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
+         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);
+
+The Python output of the function would be a tuple containing both
+output values.
+
+*/
+
+// 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 Python 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
+         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);
+
+Unlike C, this mapping does not directly modify the input value (since
+this makes no sense in Python).  Rather, the modified input value shows
+up as the return value of the function.  Thus, to apply this function
+to a Python 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.
+
+*/
+
+%include <typemaps/typemaps.swg>
diff --git a/share/swig/3.0.12/javascript/v8/arrays_javascript.i b/share/swig/3.0.12/javascript/v8/arrays_javascript.i
new file mode 100644
index 0000000..22b50be
--- /dev/null
+++ b/share/swig/3.0.12/javascript/v8/arrays_javascript.i
@@ -0,0 +1,125 @@
+/* -----------------------------------------------------------------------------
+ * arrays_javascript.i
+ *
+ * These typemaps give more natural support for arrays. The typemaps are not efficient
+ * as there is a lot of copying of the array values whenever the array is passed to C/C++
+ * from JavaScript and vice versa. The JavaScript array is expected to be the same size as the C array.
+ * An exception is thrown if they are not.
+ *
+ * Example usage:
+ * Wrapping:
+ *
+ *   %include <arrays_javascript.i>
+ *   %inline %{
+ *       extern int FiddleSticks[3];
+ *   %}
+ *
+ * Use from JavaScript like this:
+ *
+ *   var fs = [10, 11, 12];
+ *   example.FiddleSticks = fs;
+ *   fs = example.FiddleSticks;
+ * ----------------------------------------------------------------------------- */
+
+%fragment("SWIG_JSCGetIntProperty",    "header", fragment=SWIG_AsVal_frag(int)) {}
+%fragment("SWIG_JSCGetNumberProperty", "header", fragment=SWIG_AsVal_frag(double)) {}
+
+%typemap(in, fragment="SWIG_JSCGetIntProperty") int[], int[ANY]
+    (int length = 0, v8::Local<v8::Array> array, v8::Local<v8::Value> jsvalue, int i = 0, int res = 0, $*1_ltype temp) {
+  if ($input->IsArray())
+  {
+    // Convert into Array
+    array = v8::Local<v8::Array>::Cast($input);
+
+    length = $1_dim0;
+
+    $1  = ($*1_ltype *)malloc(sizeof($*1_ltype) * length);
+
+    // Get each element from array
+    for (i = 0; i < length; i++)
+    {
+      jsvalue = array->Get(i);
+
+      // Get primitive value from JSObject
+      res = SWIG_AsVal(int)(jsvalue, &temp);
+      if (!SWIG_IsOK(res))
+      {
+        SWIG_exception_fail(SWIG_ERROR, "Failed to convert $input to double");
+      }
+      arg$argnum[i] = temp;
+    }
+
+  }
+  else
+  {
+    SWIG_exception_fail(SWIG_ERROR, "$input is not JSObjectRef");
+  }
+}
+
+%typemap(freearg) int[], int[ANY] {
+    free($1);
+}
+
+%typemap(out, fragment=SWIG_From_frag(int)) int[], int[ANY] (int length = 0, int i = 0)
+{
+  length = $1_dim0;
+  v8::Local<v8::Array> array = v8::Array::New(length);
+
+  for (i = 0; i < length; i++)
+  {
+    array->Set(i, SWIG_From(int)($1[i]));
+  }
+
+
+  $result = array;
+}
+
+%typemap(in, fragment="SWIG_JSCGetNumberProperty") double[], double[ANY]
+    (int length = 0, v8::Local<v8::Array> array, v8::Local<v8::Value> jsvalue, int i = 0, int res = 0, $*1_ltype temp) {
+  if ($input->IsArray())
+  {
+    // Convert into Array
+    array = v8::Local<v8::Array>::Cast($input);
+
+    length = $1_dim0;
+
+    $1  = ($*1_ltype *)malloc(sizeof($*1_ltype) * length);
+
+    // Get each element from array
+    for (i = 0; i < length; i++)
+    {
+      jsvalue = array->Get(i);
+
+      // Get primitive value from JSObject
+      res = SWIG_AsVal(double)(jsvalue, &temp);
+      if (!SWIG_IsOK(res))
+      {
+        SWIG_exception_fail(SWIG_ERROR, "Failed to convert $input to double");
+      }
+      arg$argnum[i] = temp;
+    }
+
+  }
+  else
+  {
+    SWIG_exception_fail(SWIG_ERROR, "$input is not JSObjectRef");
+  }
+}
+
+%typemap(freearg) double[], double[ANY] {
+    free($1);
+}
+
+%typemap(out, fragment=SWIG_From_frag(double)) double[], double[ANY] (int length = 0, int i = 0)
+{
+  length = $1_dim0;
+  v8::Local<v8::Array> array = v8::Array::New(length);
+
+  for (i = 0; i < length; i++)
+  {
+    array->Set(i, SWIG_From(double)($1[i]));
+  }
+
+
+  $result = array;
+}
diff --git a/share/swig/3.0.12/javascript/v8/ccomplex.i b/share/swig/3.0.12/javascript/v8/ccomplex.i
new file mode 100644
index 0000000..8eda920
--- /dev/null
+++ b/share/swig/3.0.12/javascript/v8/ccomplex.i
@@ -0,0 +1,26 @@
+/* -----------------------------------------------------------------------------
+ * ccomplex.i
+ *
+ * C complex typemaps
+ * ISO C99:  7.3 Complex arithmetic <complex.h>
+ * ----------------------------------------------------------------------------- */
+
+
+%include <javscriptcomplex.swg>
+
+%{
+#include <complex.h>
+%}
+
+
+/* C complex constructor */
+#define CCplxConst(r, i) ((r) + I*(i))
+
+%swig_cplxflt_convn(float complex, CCplxConst, creal, cimag);
+%swig_cplxdbl_convn(double complex, CCplxConst, creal, cimag);
+%swig_cplxdbl_convn(complex, CCplxConst, creal, cimag);
+
+/* declaring the typemaps */
+%typemaps_primitive(SWIG_TYPECHECK_CPLXFLT, float complex);
+%typemaps_primitive(SWIG_TYPECHECK_CPLXDBL, double complex);
+%typemaps_primitive(SWIG_TYPECHECK_CPLXDBL, complex);
diff --git a/share/swig/2.0.11/perl5/cdata.i b/share/swig/3.0.12/javascript/v8/cdata.i
index 3679659..3679659 100644
--- a/share/swig/2.0.11/perl5/cdata.i
+++ b/share/swig/3.0.12/javascript/v8/cdata.i
diff --git a/share/swig/3.0.12/javascript/v8/complex.i b/share/swig/3.0.12/javascript/v8/complex.i
new file mode 100644
index 0000000..4c3b3c5
--- /dev/null
+++ b/share/swig/3.0.12/javascript/v8/complex.i
@@ -0,0 +1,6 @@
+#ifdef __cplusplus
+%include <std_complex.i>
+#else
+%include <ccomplex.i>
+#endif
+
diff --git a/share/swig/3.0.12/javascript/v8/exception.i b/share/swig/3.0.12/javascript/v8/exception.i
new file mode 100644
index 0000000..0246cfd
--- /dev/null
+++ b/share/swig/3.0.12/javascript/v8/exception.i
@@ -0,0 +1 @@
+%include <typemaps/exception.swg>
diff --git a/share/swig/3.0.12/javascript/v8/javascript.swg b/share/swig/3.0.12/javascript/v8/javascript.swg
new file mode 100644
index 0000000..3a83b64
--- /dev/null
+++ b/share/swig/3.0.12/javascript/v8/javascript.swg
@@ -0,0 +1,19 @@
+/* -----------------------------------------------------------------------------
+ * javascript.swg
+ *
+ * Javascript typemaps
+ * ----------------------------------------------------------------------------- */
+
+%include <typemaps/swigmacros.swg>
+
+%include <javascripttypemaps.swg>
+
+%include <javascriptruntime.swg>
+
+%include <javascripthelpers.swg>
+
+%include <javascriptkw.swg>
+
+%include <javascriptcode.swg>
+
+%include <javascriptinit.swg>
diff --git a/share/swig/3.0.12/javascript/v8/javascriptcode.swg b/share/swig/3.0.12/javascript/v8/javascriptcode.swg
new file mode 100644
index 0000000..fb7d55c
--- /dev/null
+++ b/share/swig/3.0.12/javascript/v8/javascriptcode.swg
@@ -0,0 +1,494 @@
+/* -----------------------------------------------------------------------------
+ * js_ctor:  template for wrapping a ctor.
+ *   - $jswrapper:        wrapper of called ctor
+ *   - $jslocals:         locals part of wrapper
+ *   - $jscode:           code part of wrapper
+ *   - $jsargcount:       number of arguments
+ *   - $jsmangledtype:    mangled type of class
+ * ----------------------------------------------------------------------------- */
+
+%fragment("js_ctor", "templates") %{
+static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
+  SWIGV8_HANDLESCOPE();
+  
+  v8::Handle<v8::Object> self = args.Holder();
+  $jslocals
+  if(args.Length() != $jsargcount) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for $jswrapper.");
+  $jscode
+
+  SWIGV8_SetPrivateData(self, result, SWIGTYPE_$jsmangledtype, SWIG_POINTER_OWN);
+  SWIGV8_RETURN(self);
+
+  goto fail;
+fail:
+  SWIGV8_RETURN(SWIGV8_UNDEFINED());
+}
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_veto_ctor:  a vetoing ctor for abstract classes
+ *   - $jswrapper:        name of wrapper
+ *   - $jsname:           class name
+ * ----------------------------------------------------------------------------- */
+%fragment ("js_veto_ctor", "templates")
+%{
+static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
+  SWIGV8_HANDLESCOPE();
+  
+  SWIG_exception(SWIG_ERROR, "Class $jsname can not be instantiated");
+fail:
+  SWIGV8_RETURN(SWIGV8_UNDEFINED());
+}
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_ctor_dispatcher:  dispatcher for overloaded constructors
+ *   - $jswrapper:        name of wrapper
+ *   - $jsname:           class name
+ *   - $jsdispatchcases:  part containing code for dispatching
+ * ----------------------------------------------------------------------------- */
+%fragment ("js_ctor_dispatcher", "templates")
+%{
+static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
+  SWIGV8_HANDLESCOPE();
+  
+  OverloadErrorHandler errorHandler;
+  v8::Handle<v8::Value> self;
+
+  // switch all cases by means of series of if-returns.
+  $jsdispatchcases
+
+  // default:
+  SWIG_exception_fail(SWIG_ERROR, "Illegal arguments for construction of $jsmangledname");
+
+fail:
+  SWIGV8_RETURN(SWIGV8_UNDEFINED());
+}
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_overloaded_ctor:  template for wrapping a ctor.
+ *   - $jswrapper:        wrapper of called ctor
+ *   - $jslocals:         locals part of wrapper
+ *   - $jscode:           code part of wrapper
+ *   - $jsargcount:       number of arguments
+ *   - $jsmangledtype:    mangled type of class
+ * ----------------------------------------------------------------------------- */
+%fragment("js_overloaded_ctor", "templates") %{
+static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler) {
+  SWIGV8_HANDLESCOPE();
+  
+  v8::Handle<v8::Object> self = args.Holder();
+  $jslocals
+  if(args.Length() != $jsargcount) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for $jswrapper.");
+  $jscode
+
+  SWIGV8_SetPrivateData(self, result, SWIGTYPE_$jsmangledtype, SWIG_POINTER_OWN);
+  SWIGV8_RETURN(self);
+
+  goto fail;
+fail:
+  SWIGV8_RETURN(SWIGV8_UNDEFINED());
+}
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_ctor_dispatch_case:  template for a dispatch case for calling an overloaded ctor.
+ *   - $jsargcount:       number of arguments of called ctor
+ *   - $jswrapper:        wrapper of called ctor
+ *
+ *  Note: a try-catch-like mechanism is used to switch cases
+ * ----------------------------------------------------------------------------- */
+%fragment ("js_ctor_dispatch_case", "templates")
+%{
+  if(args.Length() == $jsargcount) {
+    errorHandler.err.Clear();
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
+    self = $jswrapper(args, errorHandler);
+    if(errorHandler.err.IsEmpty()) {
+      SWIGV8_ESCAPE(self);
+    }
+#else
+    $jswrapper(args, errorHandler);
+    if(errorHandler.err.IsEmpty()) {
+      return;
+    }
+#endif
+  }
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_dtor:  template for a destructor wrapper
+ *   - $jsmangledname:  mangled class name
+ *   - $jstype:         class type
+ * ----------------------------------------------------------------------------- */
+%fragment ("js_dtor", "templates")
+%{
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
+static void $jswrapper(v8::Persistent< v8::Value > object, void *parameter) {
+  SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
+static void $jswrapper(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
+  SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
+static void $jswrapper(v8::Isolate *isolate, v8::Persistent<v8::Object> *object, SWIGV8_Proxy *proxy) {
+#else
+static void $jswrapper(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
+  v8::Local<v8::Object> object = data.GetValue();
+  SWIGV8_Proxy *proxy = data.GetParameter();
+#endif
+
+  if(proxy->swigCMemOwn && proxy->swigCObject) {
+#ifdef SWIGRUNTIME_DEBUG
+    printf("Deleting wrapped instance: %s\n", proxy->info->name);
+#endif
+    $jsfree proxy->swigCObject;
+  }
+  delete proxy;
+
+  object.Clear();
+  
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
+  object.Dispose();
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
+  object.Dispose(isolate);
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
+  object->Dispose(isolate);
+#else
+  object->Dispose();
+#endif
+}
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_dtoroverride:  template for a destructor wrapper
+ *   - $jsmangledname:  mangled class name
+ *   - $jstype:         class type
+ *   - ${destructor_action}: The custom destructor action to invoke.
+ * ----------------------------------------------------------------------------- */
+%fragment ("js_dtoroverride", "templates")
+%{
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
+static void $jswrapper(v8::Persistent<v8::Value> object, void *parameter) {
+  SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
+static void $jswrapper(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
+  SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
+static void $jswrapper(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
+#else
+static void $jswrapper(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
+  v8::Local<v8::Object> object = data.GetValue();
+  SWIGV8_Proxy *proxy = data.GetParameter();
+#endif
+
+  if(proxy->swigCMemOwn && proxy->swigCObject) {
+    $jstype arg1 = ($jstype)proxy->swigCObject;
+    ${destructor_action}
+  }
+  delete proxy;
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
+  object.Dispose();
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
+  object.Dispose(isolate);
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
+  object->Dispose(isolate);
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
+  object->Dispose();
+#else
+  object.Clear();
+#endif
+}
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_getter:  template for getter function wrappers
+ *   - $jswrapper:  wrapper function name
+ *   - $jslocals:   locals part of wrapper
+ *   - $jscode:     code part of wrapper
+ * ----------------------------------------------------------------------------- */
+%fragment("js_getter", "templates")
+%{
+static SwigV8ReturnValue $jswrapper(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
+  SWIGV8_HANDLESCOPE();
+  
+  v8::Handle<v8::Value> jsresult;
+  $jslocals
+  $jscode
+  SWIGV8_RETURN_INFO(jsresult, info);
+
+  goto fail;
+fail:
+  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
+}
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_setter:  template for setter function wrappers
+ *   - $jswrapper:  wrapper function name
+ *   - $jslocals:   locals part of wrapper
+ *   - $jscode:     code part of wrapper
+ * ----------------------------------------------------------------------------- */
+%fragment("js_setter", "templates")
+%{
+static void $jswrapper(v8::Local<v8::String> property, v8::Local<v8::Value> value,
+  const SwigV8PropertyCallbackInfoVoid &info) {
+  SWIGV8_HANDLESCOPE();
+  
+  $jslocals
+  $jscode
+  goto fail;
+fail:
+  return;
+}
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_function:  template for function wrappers
+ *   - $jswrapper:  wrapper function name
+ *   - $jslocals:   locals part of wrapper
+ *   - $jscode:     code part of wrapper
+ * ----------------------------------------------------------------------------- */
+%fragment("js_function", "templates")
+%{
+static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
+  SWIGV8_HANDLESCOPE();
+  
+  v8::Handle<v8::Value> jsresult;
+  $jslocals
+  if(args.Length() != $jsargcount) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for $jswrapper.");
+
+  $jscode
+  SWIGV8_RETURN(jsresult);
+
+  goto fail;
+fail:
+  SWIGV8_RETURN(SWIGV8_UNDEFINED());
+}
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_function_dispatcher:  template for a function dispatcher for overloaded functions
+ *   - $jswrapper:  wrapper function name
+ *   - $jsname:     name of the wrapped function
+ *   - $jslocals:   locals part of wrapper
+ *   - $jscode:     code part of wrapper
+ * ----------------------------------------------------------------------------- */
+%fragment("js_function_dispatcher", "templates")
+%{
+static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
+  SWIGV8_HANDLESCOPE();
+  
+  v8::Handle<v8::Value> jsresult;
+  OverloadErrorHandler errorHandler;
+  $jscode
+
+  SWIG_exception_fail(SWIG_ERROR, "Illegal arguments for function $jsname.");
+
+  goto fail;
+fail:
+  SWIGV8_RETURN(SWIGV8_UNDEFINED());
+}
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_overloaded_function:  template for a overloaded function
+ *   - $jswrapper:  wrapper function name
+ *   - $jslocals:   locals part of wrapper
+ *   - $jscode:     code part of wrapper
+ * ----------------------------------------------------------------------------- */
+%fragment ("js_overloaded_function", "templates")
+%{
+static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler)
+{
+  SWIGV8_HANDLESCOPE();
+  
+  v8::Handle<v8::Value> jsresult;
+  $jslocals
+  $jscode
+  SWIGV8_RETURN(jsresult);
+
+  goto fail;
+fail:
+  SWIGV8_RETURN(SWIGV8_UNDEFINED());
+}
+%}
+
+/* -----------------------------------------------------------------------------
+ * js_function_dispatch_case:  template for a case used in the function dispatcher
+ *   - $jswrapper:  wrapper function name
+ *   - $jsargcount: number of arguments of overloaded function
+ *   - $jscode:     code part of wrapper
+ * ----------------------------------------------------------------------------- */
+%fragment ("js_function_dispatch_case", "templates")
+%{
+
+  if(args.Length() == $jsargcount) {
+    errorHandler.err.Clear();
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
+    jsresult = $jswrapper(args, errorHandler);
+    if(errorHandler.err.IsEmpty()) {
+      SWIGV8_ESCAPE(jsresult);
+    }
+#else
+    $jswrapper(args, errorHandler);
+    if(errorHandler.err.IsEmpty()) {
+      return;
+    }
+#endif
+  }
+%}
+
+/* -----------------------------------------------------------------------------
+ * jsv8_declare_class_template:  template for a class template declaration.
+ *   - $jsmangledname:  mangled class name
+ * ----------------------------------------------------------------------------- */
+%fragment("jsv8_declare_class_template", "templates")
+%{
+  SWIGV8_ClientData $jsmangledname_clientData;
+%}
+
+/* -----------------------------------------------------------------------------
+ * jsv8_define_class_template:  template for a class template definition.
+ *   - $jsmangledname:  mangled class name
+ *   - $jsmangledtype:  mangled class type
+ *   - $jsdtor:         the dtor wrapper
+ * ----------------------------------------------------------------------------- */
+%fragment("jsv8_define_class_template", "templates")
+%{
+  /* Name: $jsmangledname, Type: $jsmangledtype, Dtor: $jsdtor */
+  v8::Handle<v8::FunctionTemplate> $jsmangledname_class = SWIGV8_CreateClassTemplate("$jsmangledname");
+  SWIGV8_SET_CLASS_TEMPL($jsmangledname_clientData.class_templ, $jsmangledname_class);
+  $jsmangledname_clientData.dtor = $jsdtor;
+  if (SWIGTYPE_$jsmangledtype->clientdata == 0) {
+    SWIGTYPE_$jsmangledtype->clientdata = &$jsmangledname_clientData;
+  }
+%}
+
+
+/* -----------------------------------------------------------------------------
+ * jsv8_inherit:  template for an class inherit statement.
+ *   - $jsmangledname:  mangled class name
+ *   - $jsbaseclass:    mangled name of the base class
+ * ----------------------------------------------------------------------------- */
+%fragment("jsv8_inherit", "templates")
+%{
+  if (SWIGTYPE_p$jsbaseclass->clientdata && !(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p$jsbaseclass->clientdata)->class_templ.IsEmpty()))
+  {
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
+    $jsmangledname_class->Inherit(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p$jsbaseclass->clientdata)->class_templ);
+#else
+    $jsmangledname_class->Inherit(
+      v8::Local<v8::FunctionTemplate>::New(
+        v8::Isolate::GetCurrent(),
+        static_cast<SWIGV8_ClientData *>(SWIGTYPE_p$jsbaseclass->clientdata)->class_templ)
+     );
+#endif
+
+#ifdef SWIGRUNTIME_DEBUG
+    printf("Inheritance successful $jsmangledname $jsbaseclass\n");
+#endif
+  } else {
+#ifdef SWIGRUNTIME_DEBUG
+    printf("Unable to inherit baseclass, it didn't exist $jsmangledname $jsbaseclass\n");
+#endif
+  }
+%}
+
+/* -----------------------------------------------------------------------------
+ * jsv8_create_class_instance:  template for creating an class object.
+ *   - $jsname:         class name
+ *   - $jsmangledname:  mangled class name
+ * ----------------------------------------------------------------------------- */
+%fragment("jsv8_create_class_instance", "templates")
+%{
+  /* Class: $jsname ($jsmangledname) */
+  v8::Handle<v8::FunctionTemplate> $jsmangledname_class_0 = SWIGV8_CreateClassTemplate("$jsname");
+  $jsmangledname_class_0->SetCallHandler($jsctor);
+  $jsmangledname_class_0->Inherit($jsmangledname_class);
+  $jsmangledname_class_0->SetHiddenPrototype(true);
+  v8::Handle<v8::Object> $jsmangledname_obj = $jsmangledname_class_0->GetFunction();
+%}
+
+/* -----------------------------------------------------------------------------
+ * jsv8_register_class:  template for a statement that registers a class in a parent namespace.
+ *   - $jsname:         class name
+ *   - $jsmangledname:  mangled class name
+ *   - $jsparent:       mangled name of parent namespace
+ * ----------------------------------------------------------------------------- */
+%fragment("jsv8_register_class", "templates")
+%{
+  $jsparent_obj->Set(SWIGV8_SYMBOL_NEW("$jsname"), $jsmangledname_obj);
+%}
+
+/* -----------------------------------------------------------------------------
+ * jsv8_create_namespace:  template for a statement that creates a namespace object.
+ *   - $jsmangledname:  mangled namespace name
+ * ----------------------------------------------------------------------------- */
+%fragment("jsv8_create_namespace", "templates")
+%{
+  v8::Handle<v8::Object> $jsmangledname_obj = SWIGV8_OBJECT_NEW();
+%}
+
+/* -----------------------------------------------------------------------------
+ * jsv8_register_namespace:  template for a statement that registers a namespace in a parent namespace.
+ *   - $jsname:         name of namespace
+ *   - $jsmangledname:  mangled name of namespace
+ *   - $jsparent:       mangled name of parent namespace
+ * ----------------------------------------------------------------------------- */
+%fragment("jsv8_register_namespace", "templates")
+%{
+  $jsparent_obj->Set(SWIGV8_SYMBOL_NEW("$jsname"), $jsmangledname_obj);
+%}
+
+/* -----------------------------------------------------------------------------
+ * jsv8_register_member_function:  template for a statement that registers a member function.
+ *   - $jsmangledname:  mangled class name
+ *   - $jsname:         name of the function
+ *   - $jswrapper:      wrapper of the member function
+ * ----------------------------------------------------------------------------- */
+%fragment("jsv8_register_member_function", "templates")
+%{
+  SWIGV8_AddMemberFunction($jsmangledname_class, "$jsname", $jswrapper);
+%}
+
+/* -----------------------------------------------------------------------------
+ * jsv8_register_member_variable:  template for a statement that registers a member variable.
+ *   - $jsmangledname:  mangled class name
+ *   - $jsname:         name of the function
+ *   - $jsgetter:       wrapper of the getter function
+ *   - $jssetter:       wrapper of the setter function
+ * ----------------------------------------------------------------------------- */
+%fragment("jsv8_register_member_variable", "templates")
+%{
+  SWIGV8_AddMemberVariable($jsmangledname_class, "$jsname", $jsgetter, $jssetter);
+%}
+
+/* -----------------------------------------------------------------------------
+ * jsv8_register_static_function:  template for a statement that registers a static class function.
+ *   - $jsname:         function name
+ *   - $jswrapper:      wrapper of the function
+ *   - $jsparent:       mangled name of parent namespace
+ *
+ * Note: this template is also used for global functions.
+ * ----------------------------------------------------------------------------- */
+%fragment("jsv8_register_static_function", "templates")
+%{
+  SWIGV8_AddStaticFunction($jsparent_obj, "$jsname", $jswrapper);
+%}
+
+/* -----------------------------------------------------------------------------
+ * jsv8_register_static_variable:  template for a statement that registers a static variable.
+ *   - $jsname:         variable name
+ *   - $jsparent:       mangled name of parent namespace
+ *   - $jsgetter:       wrapper of the getter function
+ *   - $jssetter:       wrapper of the setter function
+ *
+ * Note: this template is also used for global variables.
+ * ----------------------------------------------------------------------------- */
+%fragment("jsv8_register_static_variable", "templates")
+%{
+  SWIGV8_AddStaticVariable($jsparent_obj, "$jsname", $jsgetter, $jssetter);
+%}
diff --git a/share/swig/3.0.12/javascript/v8/javascriptcomplex.swg b/share/swig/3.0.12/javascript/v8/javascriptcomplex.swg
new file mode 100644
index 0000000..1c0107b
--- /dev/null
+++ b/share/swig/3.0.12/javascript/v8/javascriptcomplex.swg
@@ -0,0 +1,124 @@
+/*
+  Defines the As/From converters for double/float complex, you need to
+  provide complex Type, the Name you want to use in the converters,
+  the complex Constructor method, and the Real and Imag complex
+  accessor methods.
+
+  See the std_complex.i and ccomplex.i for concrete examples.
+*/
+
+/* the common from converter */
+%define %swig_fromcplx_conv(Type, Real, Imag)
+%fragment(SWIG_From_frag(Type),"header",
+          fragment=SWIG_From_frag(double))
+{
+SWIGINTERNINLINE v8::Handle<v8::Value>
+SWIG_From_dec(Type)(%ifcplusplus(const Type&, Type) c)
+{
+  SWIGV8_HANDLESCOPE_ESC();
+
+  v8::Local<v8::Array> vals = SWIGV8_ARRAY_NEW(2);
+
+  vals->Set(0, SWIG_From(double)(Real(c)));
+  vals->Set(1, SWIG_From(double)(Imag(c)));
+  SWIGV8_ESCAPE(vals);
+}
+}
+%enddef
+
+/* the double case */
+%define %swig_cplxdbl_conv(Type, Constructor, Real, Imag)
+%fragment(SWIG_AsVal_frag(Type),"header",
+	  fragment=SWIG_AsVal_frag(double))
+{
+SWIGINTERN int
+SWIG_AsVal_dec(Type) (v8::Handle<v8::Value> o, Type* val)
+{
+  SWIGV8_HANDLESCOPE();
+  
+  if (o->IsArray()) {
+    v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(o);
+    
+    if(array->Length() != 2) SWIG_Error(SWIG_TypeError, "Illegal argument for complex: must be array[2].");
+    double re, im;
+    int res;
+
+    res = SWIG_AsVal(double)(array->Get(0), &re);
+    if(!SWIG_IsOK(res)) {
+      return SWIG_TypeError;
+    }
+    
+    res = SWIG_AsVal(double)(array->Get(1), &im);
+    if(!SWIG_IsOK(res)) {
+      return SWIG_TypeError;
+    }
+    
+    if (val) *val = Constructor(re, im);
+    return SWIG_OK;
+  } else if(o->IsNumber()){
+    double d;
+    int res = SWIG_AddCast(SWIG_AsVal(double)(o, &d));
+    if (SWIG_IsOK(res)) {
+      if (val) *val = Constructor(d, 0.0);
+      return res;
+    }
+  }
+  return SWIG_TypeError;
+}
+}
+%swig_fromcplx_conv(Type, Real, Imag);
+%enddef
+
+/* the float case */
+%define %swig_cplxflt_conv(Type, Constructor, Real, Imag)
+%fragment(SWIG_AsVal_frag(Type),"header",
+          fragment=SWIG_AsVal_frag(float)) {
+SWIGINTERN int
+SWIG_AsVal_dec(Type) (v8::Handle<v8::Value> o, Type* val)
+{
+  SWIGV8_HANDLESCOPE();
+
+  if (o->IsArray()) {
+    v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(o);
+    
+    if(array->Length() != 2) SWIG_Error(SWIG_TypeError, "Illegal argument for complex: must be array[2].");
+    double re, im;
+    int res;
+
+    res = SWIG_AsVal(double)(array->Get(0), &re);
+    if(!SWIG_IsOK(res)) {
+      return SWIG_TypeError;
+    }
+    
+    res = SWIG_AsVal(double)(array->Get(1), &im);
+    if(!SWIG_IsOK(res)) {
+      return SWIG_TypeError;
+    }
+    
+    if ((-FLT_MAX <= re && re <= FLT_MAX) && (-FLT_MAX <= im && im <= FLT_MAX)) {
+      if (val) *val = Constructor(%numeric_cast(re, float),
+                                  %numeric_cast(im, float));
+      return SWIG_OK;
+    } else {
+      return SWIG_OverflowError;
+    }    
+  } else if(o->IsNumber()){
+    float re;
+    int res = SWIG_AddCast(SWIG_AsVal(float)(o, &re));
+    if (SWIG_IsOK(res)) {
+      if (val) *val = Constructor(re, 0.0);
+      return res;
+    }
+  }
+  return SWIG_TypeError;
+}
+}
+%swig_fromcplx_conv(Type, Real, Imag);
+%enddef
+
+#define %swig_cplxflt_convn(Type, Constructor, Real, Imag) \
+%swig_cplxflt_conv(Type, Constructor, Real, Imag)
+
+
+#define %swig_cplxdbl_convn(Type, Constructor, Real, Imag) \
+%swig_cplxdbl_conv(Type, Constructor, Real, Imag)
diff --git a/share/swig/3.0.12/javascript/v8/javascriptfragments.swg b/share/swig/3.0.12/javascript/v8/javascriptfragments.swg
new file mode 100644
index 0000000..4778bf0
--- /dev/null
+++ b/share/swig/3.0.12/javascript/v8/javascriptfragments.swg
@@ -0,0 +1,23 @@
+/*
+
+  Create a file with this name, 'javascriptfragments.swg', in your working
+  directory and add all the %fragments you want to take precedence
+  over the default ones defined by swig.
+
+  For example, if you add:
+  
+  %fragment(SWIG_AsVal_frag(int),"header") {
+   SWIGINTERNINLINE int
+   SWIG_AsVal(int)(PyObject *obj, int *val)
+   { 
+     <your code here>;
+   }
+  }
+  
+  this will replace the code used to retrieve an integer value for all
+  the typemaps that need it, including:
+  
+    int, std::vector<int>, std::list<std::pair<int,int> >, etc.
+
+    
+*/
diff --git a/share/swig/3.0.12/javascript/v8/javascripthelpers.swg b/share/swig/3.0.12/javascript/v8/javascripthelpers.swg
new file mode 100644
index 0000000..091467d
--- /dev/null
+++ b/share/swig/3.0.12/javascript/v8/javascripthelpers.swg
@@ -0,0 +1,89 @@
+%insert(runtime) %{
+
+// Note: since 3.19 there are new CallBack types, since 03.21.9 the old ones have been removed
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
+typedef v8::InvocationCallback  SwigV8FunctionCallback;
+typedef v8::AccessorGetter      SwigV8AccessorGetterCallback;
+typedef v8::AccessorSetter      SwigV8AccessorSetterCallback;
+typedef v8::AccessorInfo        SwigV8PropertyCallbackInfoVoid;
+#else
+typedef v8::FunctionCallback            SwigV8FunctionCallback;
+typedef v8::AccessorGetterCallback      SwigV8AccessorGetterCallback;
+typedef v8::AccessorSetterCallback      SwigV8AccessorSetterCallback;
+typedef v8::PropertyCallbackInfo<void>  SwigV8PropertyCallbackInfoVoid;
+#endif
+
+/**
+ * Creates a class template for a class with specified initialization function.
+ */
+SWIGRUNTIME v8::Handle<v8::FunctionTemplate> SWIGV8_CreateClassTemplate(const char* symbol) {
+    SWIGV8_HANDLESCOPE_ESC();
+    
+    v8::Local<v8::FunctionTemplate> class_templ = SWIGV8_FUNCTEMPLATE_NEW_VOID();
+    class_templ->SetClassName(SWIGV8_SYMBOL_NEW(symbol));
+
+    v8::Handle<v8::ObjectTemplate> inst_templ = class_templ->InstanceTemplate();
+    inst_templ->SetInternalFieldCount(1);
+
+    v8::Handle<v8::ObjectTemplate> equals_templ = class_templ->PrototypeTemplate();
+    equals_templ->Set(SWIGV8_SYMBOL_NEW("equals"), SWIGV8_FUNCTEMPLATE_NEW(_SWIGV8_wrap_equals));
+
+    v8::Handle<v8::ObjectTemplate> cptr_templ = class_templ->PrototypeTemplate();
+    cptr_templ->Set(SWIGV8_SYMBOL_NEW("getCPtr"), SWIGV8_FUNCTEMPLATE_NEW(_wrap_getCPtr));
+
+    SWIGV8_ESCAPE(class_templ);
+}
+
+/**
+ * Registers a class method with given name for a given class template.
+ */
+SWIGRUNTIME void SWIGV8_AddMemberFunction(v8::Handle<v8::FunctionTemplate> class_templ, const char* symbol,
+  SwigV8FunctionCallback _func) {
+    v8::Handle<v8::ObjectTemplate> proto_templ = class_templ->PrototypeTemplate();
+    proto_templ->Set(SWIGV8_SYMBOL_NEW(symbol), SWIGV8_FUNCTEMPLATE_NEW(_func));
+}
+
+/**
+ * Registers a class property with given name for a given class template.
+ */
+SWIGRUNTIME void SWIGV8_AddMemberVariable(v8::Handle<v8::FunctionTemplate> class_templ, const char* symbol,
+  SwigV8AccessorGetterCallback getter, SwigV8AccessorSetterCallback setter) {
+  v8::Handle<v8::ObjectTemplate> proto_templ = class_templ->InstanceTemplate();
+  proto_templ->SetAccessor(SWIGV8_SYMBOL_NEW(symbol), getter, setter);
+}
+
+/**
+ * Registers a class method with given name for a given object.
+ */
+SWIGRUNTIME void SWIGV8_AddStaticFunction(v8::Handle<v8::Object> obj, const char* symbol,
+  const SwigV8FunctionCallback& _func) {
+  obj->Set(SWIGV8_SYMBOL_NEW(symbol), SWIGV8_FUNCTEMPLATE_NEW(_func)->GetFunction());
+}
+
+/**
+ * Registers a class method with given name for a given object.
+ */
+SWIGRUNTIME void SWIGV8_AddStaticVariable(v8::Handle<v8::Object> obj, const char* symbol,
+  SwigV8AccessorGetterCallback getter, SwigV8AccessorSetterCallback setter) {
+  obj->SetAccessor(SWIGV8_SYMBOL_NEW(symbol), getter, setter);
+}
+
+SWIGRUNTIME void JS_veto_set_variable(v8::Local<v8::String> property, v8::Local<v8::Value> value,
+  const SwigV8PropertyCallbackInfoVoid& info)
+{
+    char buffer[256];
+    char msg[512];
+    int res;
+
+    property->WriteUtf8(buffer, 256);
+    res = sprintf(msg, "Tried to write read-only variable: %s.", buffer);
+
+    if(res<0) {
+      SWIG_exception(SWIG_ERROR, "Tried to write read-only variable.");
+    } else {
+      SWIG_exception(SWIG_ERROR, msg);
+    }
+fail: ;
+}
+
+%} // v8_helper_functions
diff --git a/share/swig/3.0.12/javascript/v8/javascriptinit.swg b/share/swig/3.0.12/javascript/v8/javascriptinit.swg
new file mode 100644
index 0000000..34befa7
--- /dev/null
+++ b/share/swig/3.0.12/javascript/v8/javascriptinit.swg
@@ -0,0 +1,115 @@
+%insert(init) %{
+
+#include <assert.h>
+
+SWIGRUNTIME void
+SWIG_V8_SetModule(void *, swig_module_info *swig_module) {
+  v8::Local<v8::Object> global_obj = SWIGV8_CURRENT_CONTEXT()->Global();
+  v8::Local<v8::External> mod = SWIGV8_EXTERNAL_NEW(swig_module);
+  assert(!mod.IsEmpty());
+  global_obj->SetHiddenValue(SWIGV8_STRING_NEW("swig_module_info_data"), mod);
+}
+
+SWIGRUNTIME swig_module_info *
+SWIG_V8_GetModule(void *) {
+  v8::Local<v8::Object> global_obj = SWIGV8_CURRENT_CONTEXT()->Global();
+  v8::Local<v8::Value> moduleinfo = global_obj->GetHiddenValue(SWIGV8_STRING_NEW("swig_module_info_data"));
+
+  if (moduleinfo.IsEmpty())
+  {
+    // It's not yet loaded
+    return 0;
+  }
+
+  v8::Local<v8::External> moduleinfo_extern = v8::Local<v8::External>::Cast(moduleinfo);
+
+  if (moduleinfo_extern.IsEmpty())
+  {
+    // Something's not right
+    return 0;
+  }
+
+  void *ptr = moduleinfo_extern->Value();
+  assert(ptr);
+  swig_module_info *retptr = static_cast<swig_module_info *>(ptr);
+  assert(retptr);
+  return retptr;
+}
+
+#define SWIG_GetModule(clientdata)                SWIG_V8_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer)       SWIG_V8_SetModule(clientdata, pointer)
+
+%}
+
+%insert(init) "swiginit.swg"
+
+// Open the initializer function definition here
+
+%fragment ("js_initializer_define", "templates") %{
+#define SWIGV8_INIT $jsname_initialize
+%}
+
+%insert(init) %{
+// Note: 'extern "C"'' disables name mangling which makes it easier to load the symbol manually
+// TODO: is it ok to do that?
+extern "C"
+#if (NODE_MODULE_VERSION < 0x000C)
+void SWIGV8_INIT (v8::Handle<v8::Object> exports)
+#else
+void SWIGV8_INIT (v8::Handle<v8::Object> exports, v8::Handle<v8::Object> /*module*/)
+#endif
+{
+  SWIG_InitializeModule(static_cast<void *>(&exports));
+
+  SWIGV8_HANDLESCOPE();
+  
+  v8::Handle<v8::Object> exports_obj = exports;
+%}
+
+
+/* -----------------------------------------------------------------------------
+ * js_initializer:  template for the module initializer function
+ *   - $jsname:                   module name
+ *   - $jsv8nspaces:              part with code creating namespace objects
+ *   - $jsv8classtemplates:       part with code creating class templates
+ *   - $jsv8wrappers:             part with code that registers wrapper functions
+ *   - $jsv8inheritance:          part with inherit statements
+ *   - $jsv8classinstances:       part with code creating class objects
+ *   - $jsv8staticwrappers:       part with code adding static functions to class objects
+ *   - $jsv8registerclasses:      part with code that registers class objects in namespaces
+ *   - $jsv8registernspaces:      part with code that registers namespaces in parent namespaces
+ * ----------------------------------------------------------------------------- */
+%fragment("js_initializer", "templates")
+%{
+  // a class template for creating proxies of undefined types
+  SWIGV8_SET_CLASS_TEMPL(SWIGV8_SWIGTYPE_Proxy_class_templ, SWIGV8_CreateClassTemplate("SwigProxy"));
+
+  /* create objects for namespaces */
+  $jsv8nspaces
+
+  /* create class templates */
+  $jsv8classtemplates
+
+  /* register wrapper functions */
+  $jsv8wrappers
+
+  /* setup inheritances */
+  $jsv8inheritance
+
+  /* class instances */
+  $jsv8classinstances
+
+  /* add static class functions and variables */
+  $jsv8staticwrappers
+
+  /* register classes */
+  $jsv8registerclasses
+
+  /* create and register namespace objects */
+  $jsv8registernspaces
+}
+
+#if defined(BUILDING_NODE_EXTENSION)
+NODE_MODULE($jsname, $jsname_initialize)
+#endif
+%}
diff --git a/share/swig/3.0.12/javascript/v8/javascriptkw.swg b/share/swig/3.0.12/javascript/v8/javascriptkw.swg
new file mode 100644
index 0000000..c3c1183
--- /dev/null
+++ b/share/swig/3.0.12/javascript/v8/javascriptkw.swg
@@ -0,0 +1,40 @@
+#ifndef JAVASCRIPT_JAVASCRIPTKW_SWG_
+#define JAVASCRIPT_JAVASCRIPTKW_SWG_
+
+/* Warnings for Java keywords */
+#define JAVASCRIPTKW(x) %keywordwarn("'" `x` "' is a javascript keyword, renaming to '_"`x`"'",rename="_%s")  `x`
+
+/* Taken from https://developer.mozilla.org/En/Core_JavaScript_1.5_Reference/Reserved_Words */
+
+JAVASCRIPTKW(break);
+JAVASCRIPTKW(case);
+JAVASCRIPTKW(catch);
+JAVASCRIPTKW(continue);
+JAVASCRIPTKW(default);
+JAVASCRIPTKW(delete);
+JAVASCRIPTKW(do);
+JAVASCRIPTKW(else);
+JAVASCRIPTKW(finally);
+JAVASCRIPTKW(for);
+JAVASCRIPTKW(function);
+JAVASCRIPTKW(if);
+JAVASCRIPTKW(in);
+JAVASCRIPTKW(instanceof);
+JAVASCRIPTKW(new);
+JAVASCRIPTKW(return);
+JAVASCRIPTKW(switch);
+JAVASCRIPTKW(this);
+JAVASCRIPTKW(throw);
+JAVASCRIPTKW(try);
+JAVASCRIPTKW(typeof);
+JAVASCRIPTKW(var);
+JAVASCRIPTKW(void);
+JAVASCRIPTKW(while);
+JAVASCRIPTKW(with);
+
+/* others bad names if any*/
+// for example %namewarn("321:clone() is a javascript bad method name") *::clone();
+
+#undef JAVASCRIPTKW
+
+#endif //JAVASCRIPT_JAVASCRIPTKW_SWG_
diff --git a/share/swig/3.0.12/javascript/v8/javascriptprimtypes.swg b/share/swig/3.0.12/javascript/v8/javascriptprimtypes.swg
new file mode 100644
index 0000000..c0055c4
--- /dev/null
+++ b/share/swig/3.0.12/javascript/v8/javascriptprimtypes.swg
@@ -0,0 +1,206 @@
+/* ------------------------------------------------------------
+ * Primitive Types
+ * ------------------------------------------------------------ */
+
+/* boolean */
+
+%fragment(SWIG_From_frag(bool),"header") {
+SWIGINTERNINLINE
+v8::Handle<v8::Value>
+SWIG_From_dec(bool)(bool value)
+{
+  return SWIGV8_BOOLEAN_NEW(value);
+}
+}
+
+%fragment(SWIG_AsVal_frag(bool),"header",
+          fragment=SWIG_AsVal_frag(long)) {
+SWIGINTERN
+int SWIG_AsVal_dec(bool)(v8::Handle<v8::Value> obj, bool *val)
+{
+  if(!obj->IsBoolean()) {
+    return SWIG_ERROR;
+  }
+
+  if (val) *val = obj->BooleanValue();
+  return SWIG_OK;
+}
+}
+
+/* int */
+
+%fragment(SWIG_From_frag(int),"header") {
+SWIGINTERNINLINE
+v8::Handle<v8::Value> SWIG_From_dec(int)(int value)
+{
+  return SWIGV8_INT32_NEW(value);
+}
+}
+
+%fragment(SWIG_AsVal_frag(int),"header") {
+SWIGINTERN
+int SWIG_AsVal_dec(int)(v8::Handle<v8::Value> valRef, int* val)
+{
+  if (!valRef->IsNumber()) {
+    return SWIG_TypeError;
+  }
+  if(val) *val = valRef->IntegerValue();
+
+  return SWIG_OK;
+}
+}
+
+/* long */
+
+%fragment(SWIG_From_frag(long),"header") {
+SWIGINTERNINLINE
+v8::Handle<v8::Value> SWIG_From_dec(long)(long value)
+{
+  return SWIGV8_NUMBER_NEW(value);
+}
+}
+
+%fragment(SWIG_AsVal_frag(long),"header",
+          fragment="SWIG_CanCastAsInteger") {
+SWIGINTERN
+int SWIG_AsVal_dec(long)(v8::Handle<v8::Value> obj, long* val)
+{
+  if (!obj->IsNumber()) {
+    return SWIG_TypeError;
+  }
+  if(val) *val = (long) obj->IntegerValue();
+
+  return SWIG_OK;
+}
+}
+
+/* unsigned long */
+
+%fragment(SWIG_From_frag(unsigned long),"header",
+          fragment=SWIG_From_frag(long)) {
+SWIGINTERNINLINE
+v8::Handle<v8::Value> SWIG_From_dec(unsigned long)(unsigned long value)
+{
+  return (value > LONG_MAX) ?
+    SWIGV8_INTEGER_NEW_UNS(value) : SWIGV8_INTEGER_NEW(%numeric_cast(value,long));
+}
+}
+
+%fragment(SWIG_AsVal_frag(unsigned long),"header",
+          fragment="SWIG_CanCastAsInteger") {
+SWIGINTERN
+int SWIG_AsVal_dec(unsigned long)(v8::Handle<v8::Value> obj, unsigned long *val)
+{
+  if(!obj->IsNumber()) {
+    return SWIG_TypeError;
+  }
+
+  long longVal = (long) obj->NumberValue();
+
+  if(longVal < 0) {
+      return SWIG_OverflowError;
+  }
+
+  if(val) *val = longVal;
+
+  return SWIG_OK;
+}
+}
+
+/* long long */
+// Note: these are copied from 'long' and probably need fixing
+
+%fragment(SWIG_From_frag(long long),"header",
+    fragment=SWIG_From_frag(long),
+    fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERNINLINE
+v8::Handle<v8::Value> SWIG_From_dec(long long)(long long value)
+{
+  return SWIGV8_NUMBER_NEW(value);
+}
+%#endif
+}
+
+%fragment(SWIG_AsVal_frag(long long),"header",
+    fragment=SWIG_AsVal_frag(long),
+    fragment="SWIG_CanCastAsInteger",
+    fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERN
+int SWIG_AsVal_dec(long long)(v8::Handle<v8::Value> obj, long long* val)
+{
+  if (!obj->IsNumber()) {
+    return SWIG_TypeError;
+  }
+  if(val) *val = (long long) obj->IntegerValue();
+
+  return SWIG_OK;
+}
+%#endif
+}
+
+/* unsigned long long */
+// Note: these are copied from 'unsigned long' and probably need fixing
+
+%fragment(SWIG_From_frag(unsigned long long),"header",
+    fragment=SWIG_From_frag(long long),
+    fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERNINLINE
+v8::Handle<v8::Value> SWIG_From_dec(unsigned long long)(unsigned long long value)
+{
+  return (value > LONG_MAX) ?
+    SWIGV8_INTEGER_NEW_UNS(value) : SWIGV8_INTEGER_NEW(%numeric_cast(value,long));
+}
+%#endif
+}
+
+%fragment(SWIG_AsVal_frag(unsigned long long),"header",
+    fragment=SWIG_AsVal_frag(unsigned long),
+    fragment="SWIG_CanCastAsInteger",
+    fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERN
+int SWIG_AsVal_dec(unsigned long long)(v8::Handle<v8::Value> obj, unsigned long long *val)
+{
+  if(!obj->IsNumber()) {
+    return SWIG_TypeError;
+  }
+
+  long long longVal = (long long) obj->NumberValue();
+
+  if(longVal < 0) {
+      return SWIG_OverflowError;
+  }
+
+  if(val) *val = longVal;
+
+  return SWIG_OK;
+}
+%#endif
+}
+
+/* double */
+
+%fragment(SWIG_From_frag(double),"header") {
+SWIGINTERN
+v8::Handle<v8::Value> SWIG_From_dec(double) (double val)
+{
+  return SWIGV8_NUMBER_NEW(val);
+}
+}
+
+%fragment(SWIG_AsVal_frag(double),"header") {
+SWIGINTERN
+int SWIG_AsVal_dec(double)(v8::Handle<v8::Value> obj, double *val)
+{
+  if(!obj->IsNumber()) {
+    return SWIG_TypeError;
+  }
+  if(val) *val = obj->NumberValue();
+
+  return SWIG_OK;
+}
+}
+
diff --git a/share/swig/3.0.12/javascript/v8/javascriptrun.swg b/share/swig/3.0.12/javascript/v8/javascriptrun.swg
new file mode 100644
index 0000000..5ac52a5
--- /dev/null
+++ b/share/swig/3.0.12/javascript/v8/javascriptrun.swg
@@ -0,0 +1,621 @@
+/* ---------------------------------------------------------------------------
+ * These typedefs and defines are used to deal with v8 API changes
+ *
+ * ---------------------------------------------------------------------------*/
+
+// First v8 version that uses "SetWeak" and not "MakeWeak"
+
+#define SWIGV8_SETWEAK_VERSION 0x032224
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031803)
+#define SWIGV8_STRING_NEW2(cstr, len) v8::String::New(cstr, len)
+#else
+#define SWIGV8_STRING_NEW2(cstr, len) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), cstr, v8::String::kNormalString, len)
+#endif
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
+typedef v8::Handle<v8::Value> SwigV8ReturnValue;
+typedef v8::Arguments SwigV8Arguments;
+typedef v8::AccessorInfo SwigV8PropertyCallbackInfo;
+#define SWIGV8_RETURN(val) return scope.Close(val)
+#define SWIGV8_RETURN_INFO(val, info) return scope.Close(val)
+#else
+typedef void SwigV8ReturnValue;
+typedef v8::FunctionCallbackInfo<v8::Value> SwigV8Arguments;
+typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo;
+#define SWIGV8_RETURN(val) args.GetReturnValue().Set(val); return
+#define SWIGV8_RETURN_INFO(val, info) info.GetReturnValue().Set(val); return
+#endif
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032117)
+#define SWIGV8_HANDLESCOPE() v8::HandleScope scope
+#define SWIGV8_HANDLESCOPE_ESC() v8::HandleScope scope
+#define SWIGV8_ESCAPE(val) return scope.Close(val)
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032224)
+#define SWIGV8_HANDLESCOPE() v8::HandleScope scope(v8::Isolate::GetCurrent());
+#define SWIGV8_HANDLESCOPE_ESC() v8::HandleScope scope(v8::Isolate::GetCurrent());
+#define SWIGV8_ESCAPE(val) return scope.Close(val)
+#else
+#define SWIGV8_HANDLESCOPE() v8::HandleScope scope(v8::Isolate::GetCurrent());
+#define SWIGV8_HANDLESCOPE_ESC() v8::EscapableHandleScope scope(v8::Isolate::GetCurrent());
+#define SWIGV8_ESCAPE(val) return scope.Escape(val)
+#endif
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032224)
+#define SWIGV8_ADJUST_MEMORY(size) v8::V8::AdjustAmountOfExternalAllocatedMemory(size)
+#define SWIGV8_CURRENT_CONTEXT() v8::Context::GetCurrent()
+#define SWIGV8_THROW_EXCEPTION(err) v8::ThrowException(err)
+#define SWIGV8_STRING_NEW(str) v8::String::New(str)
+#define SWIGV8_SYMBOL_NEW(sym) v8::String::NewSymbol(sym)
+#else
+#define SWIGV8_ADJUST_MEMORY(size) v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(size)
+#define SWIGV8_CURRENT_CONTEXT() v8::Isolate::GetCurrent()->GetCurrentContext()
+#define SWIGV8_THROW_EXCEPTION(err) v8::Isolate::GetCurrent()->ThrowException(err)
+#define SWIGV8_STRING_NEW(str) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), str)
+#define SWIGV8_SYMBOL_NEW(sym) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), sym)
+#endif
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032318)
+#define SWIGV8_ARRAY_NEW() v8::Array::New()
+#define SWIGV8_BOOLEAN_NEW(bool) v8::Boolean::New(bool)
+#define SWIGV8_EXTERNAL_NEW(val) v8::External::New(val)
+#define SWIGV8_FUNCTEMPLATE_NEW(func) v8::FunctionTemplate::New(func)
+#define SWIGV8_FUNCTEMPLATE_NEW_VOID() v8::FunctionTemplate::New()
+#define SWIGV8_INT32_NEW(num) v8::Int32::New(num)
+#define SWIGV8_INTEGER_NEW(num) v8::Integer::New(num)
+#define SWIGV8_INTEGER_NEW_UNS(num) v8::Integer::NewFromUnsigned(num)
+#define SWIGV8_NUMBER_NEW(num) v8::Number::New(num)
+#define SWIGV8_OBJECT_NEW() v8::Object::New()
+#define SWIGV8_UNDEFINED() v8::Undefined()
+#define SWIGV8_NULL() v8::Null()
+#else
+#define SWIGV8_ARRAY_NEW() v8::Array::New(v8::Isolate::GetCurrent())
+#define SWIGV8_BOOLEAN_NEW(bool) v8::Boolean::New(v8::Isolate::GetCurrent(), bool)
+#define SWIGV8_EXTERNAL_NEW(val) v8::External::New(v8::Isolate::GetCurrent(), val)
+#define SWIGV8_FUNCTEMPLATE_NEW(func) v8::FunctionTemplate::New(v8::Isolate::GetCurrent(), func)
+#define SWIGV8_FUNCTEMPLATE_NEW_VOID() v8::FunctionTemplate::New(v8::Isolate::GetCurrent())
+#define SWIGV8_INT32_NEW(num) v8::Int32::New(v8::Isolate::GetCurrent(), num)
+#define SWIGV8_INTEGER_NEW(num) v8::Integer::New(v8::Isolate::GetCurrent(), num)
+#define SWIGV8_INTEGER_NEW_UNS(num) v8::Integer::NewFromUnsigned(v8::Isolate::GetCurrent(), num)
+#define SWIGV8_NUMBER_NEW(num) v8::Number::New(v8::Isolate::GetCurrent(), num)
+#define SWIGV8_OBJECT_NEW() v8::Object::New(v8::Isolate::GetCurrent())
+#define SWIGV8_UNDEFINED() v8::Undefined(v8::Isolate::GetCurrent())
+#define SWIGV8_NULL() v8::Null(v8::Isolate::GetCurrent())
+#endif
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
+#define SWIGV8_SET_CLASS_TEMPL(class_templ, class) class_templ = v8::Persistent<v8::FunctionTemplate>::New(class);
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
+#define SWIGV8_SET_CLASS_TEMPL(class_templ, class) class_templ = v8::Persistent<v8::FunctionTemplate>::New(v8::Isolate::GetCurrent(), class);
+#else
+#define SWIGV8_SET_CLASS_TEMPL(class_templ, class) class_templ.Reset(v8::Isolate::GetCurrent(), class);
+#endif
+
+/* ---------------------------------------------------------------------------
+ * Error handling
+ *
+ * ---------------------------------------------------------------------------*/
+
+#define SWIG_Error(code, msg)     SWIGV8_ErrorHandler.error(code, msg)
+#define SWIG_exception(code, msg) do { SWIGV8_ErrorHandler.error(code, msg); SWIG_fail; } while (0)
+#define SWIG_fail                 goto fail
+#define SWIGV8_OVERLOAD false
+
+SWIGINTERN void SWIG_V8_Raise(const char *msg) {
+  SWIGV8_THROW_EXCEPTION(v8::Exception::Error(SWIGV8_STRING_NEW(msg)));
+}
+
+/*
+  Note: There are two contexts for handling errors.
+  A static V8ErrorHandler is used in not overloaded methods.
+  For overloaded methods the throwing type checking mechanism is used
+  during dispatching. As V8 exceptions can not be resetted properly
+  the trick is to use a dynamic ErrorHandler with same local name as the global
+  one.
+
+  - See defintion of SWIG_Error above.
+  - See code templates 'JS_function_dispatcher', 'JS_functionwrapper_overload',
+    and 'JS_function_dispatch_case' in javascriptcode.swg
+
+*/
+class V8ErrorHandler {
+public:
+  virtual ~V8ErrorHandler() {}
+  virtual void error(int code, const char *msg) {
+    SWIG_V8_Raise(msg);
+  }
+};
+// this is used in usually
+SWIGRUNTIME V8ErrorHandler SWIGV8_ErrorHandler;
+
+// instances of this are used in overloaded functions
+class OverloadErrorHandler: public V8ErrorHandler {
+public:
+  virtual void error(int code, const char *msg) {
+    err = v8::Exception::Error(SWIGV8_STRING_NEW(msg));
+    if(code != SWIG_TypeError) {
+        SWIGV8_THROW_EXCEPTION(err);
+    }
+  }
+  v8::Handle<v8::Value> err;
+};
+
+/* ---------------------------------------------------------------------------
+ * Basic Proxy object
+ *
+ * ---------------------------------------------------------------------------*/
+
+// Note: to trigger the v8 gc more often one can tell v8 about the memory consumption
+// TODO: we could add a v8 specific parameter to control this value
+#define SWIGV8_AVG_OBJ_SIZE 1000
+
+class SWIGV8_Proxy {
+public:
+  SWIGV8_Proxy(): swigCMemOwn(false), swigCObject(0), info(0) {
+    SWIGV8_ADJUST_MEMORY(SWIGV8_AVG_OBJ_SIZE);
+  };
+
+  ~SWIGV8_Proxy() {
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
+    handle.ClearWeak();
+    handle.Dispose();
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
+    handle.ClearWeak(v8::Isolate::GetCurrent());
+    handle.Dispose(v8::Isolate::GetCurrent());
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
+    handle.ClearWeak();
+    handle.Dispose();
+#else    
+    handle.ClearWeak();
+    handle.Reset();
+#endif
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
+    handle.Clear();
+#endif
+
+    SWIGV8_ADJUST_MEMORY(-SWIGV8_AVG_OBJ_SIZE);
+  }
+
+  bool swigCMemOwn;
+  void *swigCObject;
+  swig_type_info *info;
+  v8::Persistent<v8::Object> handle;
+};
+
+class SWIGV8_ClientData {
+public:
+  v8::Persistent<v8::FunctionTemplate> class_templ;
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
+  void (*dtor) (v8::Persistent< v8::Value> object, void *parameter);
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
+  void (*dtor) (v8::Isolate *isolate, v8::Persistent< v8::Value> object, void *parameter);
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
+  void (*dtor) (v8::Isolate *isolate, v8::Persistent< v8::Object > *object, SWIGV8_Proxy *proxy);
+#else
+  void (*dtor) (const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data);
+#endif
+};
+
+SWIGRUNTIME v8::Persistent<v8::FunctionTemplate> SWIGV8_SWIGTYPE_Proxy_class_templ;
+
+SWIGRUNTIME int SWIG_V8_ConvertInstancePtr(v8::Handle<v8::Object> objRef, void **ptr, swig_type_info *info, int flags) {
+  SWIGV8_HANDLESCOPE();
+
+  if(objRef->InternalFieldCount() < 1) return SWIG_ERROR;
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031511)
+  v8::Handle<v8::Value> cdataRef = objRef->GetInternalField(0);
+  SWIGV8_Proxy *cdata = static_cast<SWIGV8_Proxy *>(v8::External::Unwrap(cdataRef));
+#else
+  SWIGV8_Proxy *cdata = static_cast<SWIGV8_Proxy *>(objRef->GetAlignedPointerFromInternalField(0));
+#endif
+
+  if(cdata == NULL) {
+    return SWIG_ERROR;
+  }
+  if(cdata->info != info) {
+    swig_cast_info *tc = SWIG_TypeCheckStruct(cdata->info, info);
+    if (!tc && cdata->info->name) {
+      tc = SWIG_TypeCheck(cdata->info->name, info);
+    }
+    bool type_valid = tc != 0;
+    if(!type_valid) {
+      return SWIG_TypeError;
+    }
+  }
+  *ptr = cdata->swigCObject;
+  if(flags & SWIG_POINTER_DISOWN) {
+    cdata->swigCMemOwn = false;
+  }
+  return SWIG_OK;
+}
+
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
+SWIGRUNTIME void SWIGV8_Proxy_DefaultDtor(v8::Persistent< v8::Value > object, void *parameter) {
+  SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
+SWIGRUNTIME void SWIGV8_Proxy_DefaultDtor(v8::Isolate *, v8::Persistent< v8::Value > object, void *parameter) {
+  SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
+SWIGRUNTIME void SWIGV8_Proxy_DefaultDtor(v8::Isolate *, v8::Persistent< v8::Object > *object, SWIGV8_Proxy *proxy) {
+#else
+SWIGRUNTIME void SWIGV8_Proxy_DefaultDtor(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
+  SWIGV8_Proxy *proxy = data.GetParameter();
+#endif
+
+  delete proxy;
+}
+
+SWIGRUNTIME int SWIG_V8_GetInstancePtr(v8::Handle<v8::Value> valRef, void **ptr) {
+  if(!valRef->IsObject()) {
+    return SWIG_TypeError;
+  }
+  v8::Handle<v8::Object> objRef = valRef->ToObject();
+
+  if(objRef->InternalFieldCount() < 1) return SWIG_ERROR;
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031511)
+  v8::Handle<v8::Value> cdataRef = objRef->GetInternalField(0);
+  SWIGV8_Proxy *cdata = static_cast<SWIGV8_Proxy *>(v8::External::Unwrap(cdataRef));
+#else
+  SWIGV8_Proxy *cdata = static_cast<SWIGV8_Proxy *>(objRef->GetAlignedPointerFromInternalField(0));
+#endif
+
+  if(cdata == NULL) {
+    return SWIG_ERROR;
+  }
+
+  *ptr = cdata->swigCObject;
+
+  return SWIG_OK;
+}
+
+SWIGRUNTIME void SWIGV8_SetPrivateData(v8::Handle<v8::Object> obj, void *ptr, swig_type_info *info, int flags) {
+  SWIGV8_Proxy *cdata = new SWIGV8_Proxy();
+  cdata->swigCObject = ptr;
+  cdata->swigCMemOwn = (flags & SWIG_POINTER_OWN) ? 1 : 0;
+  cdata->info = info;
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031511)
+  obj->SetPointerInInternalField(0, cdata);
+#else
+  obj->SetAlignedPointerInInternalField(0, cdata);
+#endif
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
+  cdata->handle = v8::Persistent<v8::Object>::New(obj);
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
+  cdata->handle = v8::Persistent<v8::Object>::New(v8::Isolate::GetCurrent(), obj);
+#else
+  cdata->handle.Reset(v8::Isolate::GetCurrent(), obj);
+#endif
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
+  // clientdata must be set for owned data as we need to register the dtor
+  if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
+    cdata->handle.MakeWeak(cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor);
+  } else {
+    cdata->handle.MakeWeak(cdata, SWIGV8_Proxy_DefaultDtor);
+  }
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031918)
+  if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
+    cdata->handle.MakeWeak(v8::Isolate::GetCurrent(), cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor);
+  } else {
+    cdata->handle.MakeWeak(v8::Isolate::GetCurrent(), cdata, SWIGV8_Proxy_DefaultDtor);
+  }
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
+  if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
+    cdata->handle.MakeWeak(cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor);
+  } else {
+    cdata->handle.MakeWeak(cdata, SWIGV8_Proxy_DefaultDtor);
+  }
+#else
+  if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
+    cdata->handle.SetWeak(cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor);
+  } else {
+    cdata->handle.SetWeak(cdata, SWIGV8_Proxy_DefaultDtor);
+  }
+#endif
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
+  cdata->handle.MarkIndependent();
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
+  cdata->handle.MarkIndependent(v8::Isolate::GetCurrent());
+#else
+  cdata->handle.MarkIndependent();
+#endif
+
+}
+
+SWIGRUNTIME int SWIG_V8_ConvertPtr(v8::Handle<v8::Value> valRef, void **ptr, swig_type_info *info, int flags) {
+  SWIGV8_HANDLESCOPE();
+  
+  /* special case: JavaScript null => C NULL pointer */
+  if(valRef->IsNull()) {
+    *ptr=0;
+    return SWIG_OK;
+  }
+  if(!valRef->IsObject()) {
+    return SWIG_TypeError;
+  }
+  v8::Handle<v8::Object> objRef = valRef->ToObject();
+  return SWIG_V8_ConvertInstancePtr(objRef, ptr, info, flags);
+}
+
+SWIGRUNTIME v8::Handle<v8::Value> SWIG_V8_NewPointerObj(void *ptr, swig_type_info *info, int flags) {
+  SWIGV8_HANDLESCOPE_ESC();
+  
+  v8::Handle<v8::FunctionTemplate> class_templ;
+
+  if (ptr == NULL) {
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
+    SWIGV8_ESCAPE(SWIGV8_NULL());
+#else    
+    v8::Local<v8::Primitive> result = SWIGV8_NULL();
+    SWIGV8_ESCAPE(result);
+#endif
+  }
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
+  if(info->clientdata != 0) {
+    class_templ = ((SWIGV8_ClientData*) info->clientdata)->class_templ;
+  } else {
+    class_templ = SWIGV8_SWIGTYPE_Proxy_class_templ;
+  }
+#else
+  v8::Isolate *isolate = v8::Isolate::GetCurrent();
+
+  if(info->clientdata != 0) {
+    class_templ = v8::Local<v8::FunctionTemplate>::New(isolate, ((SWIGV8_ClientData*) info->clientdata)->class_templ);
+  } else {
+    class_templ = v8::Local<v8::FunctionTemplate>::New(isolate, SWIGV8_SWIGTYPE_Proxy_class_templ);
+  }
+#endif
+
+//  v8::Handle<v8::Object> result = class_templ->InstanceTemplate()->NewInstance();
+  v8::Local<v8::Object> result = class_templ->InstanceTemplate()->NewInstance();
+  SWIGV8_SetPrivateData(result, ptr, info, flags);
+
+  SWIGV8_ESCAPE(result);
+}
+
+#define SWIG_ConvertPtr(obj, ptr, info, flags)    SWIG_V8_ConvertPtr(obj, ptr, info, flags)
+#define SWIG_NewPointerObj(ptr, info, flags)      SWIG_V8_NewPointerObj(ptr, info, flags)
+
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_V8_ConvertInstancePtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(thisvalue, type, flags)     SWIG_V8_NewPointerObj(thisvalue, type, flags)
+
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_V8_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_V8_NewPointerObj(ptr, type, 0)
+
+#define SWIG_GetInstancePtr(obj, ptr)    SWIG_V8_GetInstancePtr(obj, ptr)
+
+SWIGRUNTIME SwigV8ReturnValue _SWIGV8_wrap_equals(const SwigV8Arguments &args) {
+  SWIGV8_HANDLESCOPE();
+  
+  v8::Handle<v8::Value> jsresult;
+  void *arg1 = (void *) 0 ;
+  void *arg2 = (void *) 0 ;
+  bool result;
+  int res1;
+  int res2;
+
+  if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for equals.");
+
+  res1 = SWIG_GetInstancePtr(args.Holder(), &arg1);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ERROR, "Could not get pointer from 'this' object for equals.");
+  }
+  res2 = SWIG_GetInstancePtr(args[0], &arg2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "equals" "', argument " "1"" of type '" "void *""'");
+  }
+
+  result = (bool)(arg1 == arg2);
+  jsresult =  SWIGV8_BOOLEAN_NEW(result);
+
+  SWIGV8_RETURN(jsresult);
+  goto fail;
+fail:
+  SWIGV8_RETURN(SWIGV8_UNDEFINED());
+}
+
+SWIGRUNTIME SwigV8ReturnValue _wrap_getCPtr(const SwigV8Arguments &args) {
+  SWIGV8_HANDLESCOPE();
+  
+  v8::Handle<v8::Value> jsresult;
+  void *arg1 = (void *) 0 ;
+  long result;
+  int res1;
+
+  res1 = SWIG_GetInstancePtr(args.Holder(), &arg1);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getCPtr" "', argument " "1"" of type '" "void *""'");
+  }
+
+  result = (long)arg1;
+  jsresult = SWIGV8_NUMBER_NEW(result);
+
+  SWIGV8_RETURN(jsresult);
+  goto fail;
+fail:
+  SWIGV8_RETURN(SWIGV8_UNDEFINED());
+}
+
+/* ---------------------------------------------------------------------------
+ * PackedData object
+ *
+ * ---------------------------------------------------------------------------*/
+
+class SwigV8PackedData {
+public:
+  SwigV8PackedData(void *data, size_t size, swig_type_info *type): data(data), size(size), type(type) {};
+
+  ~SwigV8PackedData() {
+  };
+
+  void *data;
+  size_t size;
+  swig_type_info *type;
+
+  v8::Persistent<v8::Object> handle;
+};
+
+SWIGRUNTIMEINLINE
+int SwigV8Packed_Check(v8::Handle<v8::Value> valRef) {
+  SWIGV8_HANDLESCOPE();
+  
+  v8::Handle<v8::Object> objRef = valRef->ToObject();
+  if(objRef->InternalFieldCount() < 1) return false;
+  v8::Handle<v8::Value> flag = objRef->GetHiddenValue(SWIGV8_STRING_NEW("__swig__packed_data__"));
+  return (flag->IsBoolean() && flag->BooleanValue());
+}
+
+SWIGRUNTIME
+swig_type_info *SwigV8Packed_UnpackData(v8::Handle<v8::Value> valRef, void *ptr, size_t size) {
+  if (SwigV8Packed_Check(valRef)) {
+    SWIGV8_HANDLESCOPE();
+    
+    SwigV8PackedData *sobj;
+
+    v8::Handle<v8::Object> objRef = valRef->ToObject();
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031511)
+    v8::Handle<v8::Value> cdataRef = objRef->GetInternalField(0);
+    sobj = static_cast<SwigV8PackedData*>(v8::External::Unwrap(cdataRef));
+#else
+    sobj = static_cast<SwigV8PackedData*>(objRef->GetAlignedPointerFromInternalField(0));
+#endif
+    if (sobj == NULL || sobj->size != size) return 0;
+    memcpy(ptr, sobj->data, size);
+    return sobj->type;
+  } else {
+    return 0;
+  }
+}
+
+SWIGRUNTIME
+int SWIGV8_ConvertPacked(v8::Handle<v8::Value> valRef, void *ptr, size_t sz, swig_type_info *ty) {
+  swig_type_info *to = SwigV8Packed_UnpackData(valRef, ptr, sz);
+  if (!to) return SWIG_ERROR;
+  if (ty) {
+    if (to != ty) {
+      /* check type cast? */
+      swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
+      if (!tc) return SWIG_ERROR;
+    }
+  }
+  return SWIG_OK;
+}
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
+SWIGRUNTIME void _wrap_SwigV8PackedData_delete(v8::Persistent< v8::Value > object, void *parameter) {
+  SwigV8PackedData *cdata = static_cast<SwigV8PackedData *>(parameter);
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
+SWIGRUNTIME void _wrap_SwigV8PackedData_delete(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
+  SwigV8PackedData *cdata = static_cast<SwigV8PackedData *>(parameter);
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
+SWIGRUNTIME void _wrap_SwigV8PackedData_delete(v8::Isolate *isolate, v8::Persistent<v8::Object> *object, SwigV8PackedData *cdata) {
+#else
+SWIGRUNTIME void _wrap_SwigV8PackedData_delete(const v8::WeakCallbackData<v8::Object, SwigV8PackedData> &data) {
+  v8::Local<v8::Object> object = data.GetValue();
+  SwigV8PackedData *cdata = data.GetParameter();
+#endif
+
+  delete cdata;
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
+  object.Clear();
+  object.Dispose();
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
+  object.Clear();
+  object.Dispose(isolate);
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
+  object->Dispose(isolate);
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
+  object->Dispose();
+#else
+  object.Clear();
+#endif
+}
+
+SWIGRUNTIME
+v8::Handle<v8::Value> SWIGV8_NewPackedObj(void *data, size_t size, swig_type_info *type) {
+  SWIGV8_HANDLESCOPE_ESC();
+
+  SwigV8PackedData *cdata = new SwigV8PackedData(data, size, type);
+//  v8::Handle<v8::Object> obj = SWIGV8_OBJECT_NEW();
+  v8::Local<v8::Object> obj = SWIGV8_OBJECT_NEW();
+
+  obj->SetHiddenValue(SWIGV8_STRING_NEW("__swig__packed_data__"), SWIGV8_BOOLEAN_NEW(true));
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031511)
+  obj->SetPointerInInternalField(0, cdata);
+#else
+  obj->SetAlignedPointerInInternalField(0, cdata);
+#endif
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
+  cdata->handle = v8::Persistent<v8::Object>::New(obj);
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
+  cdata->handle = v8::Persistent<v8::Object>::New(v8::Isolate::GetCurrent(), obj);
+#else
+  cdata->handle.Reset(v8::Isolate::GetCurrent(), obj);
+#endif
+
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
+  cdata->handle.MakeWeak(cdata, _wrap_SwigV8PackedData_delete);
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031918)
+  cdata->handle.MakeWeak(v8::Isolate::GetCurrent(), cdata, _wrap_SwigV8PackedData_delete);
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
+  cdata->handle.MakeWeak(cdata, _wrap_SwigV8PackedData_delete);
+#else
+  cdata->handle.SetWeak(cdata, _wrap_SwigV8PackedData_delete);
+//  v8::V8::SetWeak(&cdata->handle, cdata, _wrap_SwigV8PackedData_delete);
+#endif
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
+  cdata->handle.MarkIndependent();
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
+  cdata->handle.MarkIndependent(v8::Isolate::GetCurrent());
+#else
+  cdata->handle.MarkIndependent();
+#endif
+
+  SWIGV8_ESCAPE(obj);
+}
+
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIGV8_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIGV8_NewPackedObj(ptr, sz, type)
+
+
+/* ---------------------------------------------------------------------------
+ * Support for IN/OUTPUT typemaps (see Lib/typemaps/inoutlist.swg)
+ *
+ * ---------------------------------------------------------------------------*/
+
+SWIGRUNTIME
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
+v8::Handle<v8::Value> SWIGV8_AppendOutput(v8::Handle<v8::Value> result, v8::Handle<v8::Value> obj) {
+#else
+v8::Handle<v8::Value> SWIGV8_AppendOutput(v8::Local<v8::Value> result, v8::Handle<v8::Value> obj) {
+#endif
+  SWIGV8_HANDLESCOPE_ESC();
+  
+  if (result->IsUndefined()) {
+    result = SWIGV8_ARRAY_NEW();
+  }
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
+  v8::Handle<v8::Array> arr = v8::Handle<v8::Array>::Cast(result);
+#else  
+  v8::Local<v8::Array> arr = v8::Local<v8::Array>::Cast(result);
+#endif
+  arr->Set(arr->Length(), obj);
+
+  SWIGV8_ESCAPE(arr);
+}
diff --git a/share/swig/3.0.12/javascript/v8/javascriptruntime.swg b/share/swig/3.0.12/javascript/v8/javascriptruntime.swg
new file mode 100644
index 0000000..0e40593
--- /dev/null
+++ b/share/swig/3.0.12/javascript/v8/javascriptruntime.swg
@@ -0,0 +1,66 @@
+/* -----------------------------------------------------------------------------
+ * javascriptruntime.swg
+ *
+ * ----------------------------------------------------------------------------- */
+
+// V8 Version Macro
+// ----------------
+//
+// v8 added version macros V8_MAJOR_VERSION, V8_MINOR_VERSION, V8_BUILD_NUMBER
+// and V8_PATCH_LEVEL in version 4.3.0.  SWIG generated code uses these if
+// they are defined - to support earlier versions you can specify the V8 version
+// in use via the command line when you run SWIG:
+//
+//   swig -c++ -javascript -v8 -DV8_VERSION=0x032530 example.i
+//
+// Or code in the interface file using SWIG_V8_VERSION:
+//
+//   %begin %{#define SWIG_V8_VERSION 0x031110%}
+//
+// This is specified as a hex constant, but the constant is read as pairs of
+// decimal digits, so for V8 3.25.30 use constant 0x032530.  This scheme can't
+// represent components > 99, but this constant is only useful for V8 < 4.3.0,
+// and no V8 versions from that era had a component > 99.
+
+%define %swig_v8_define_version(version)
+%insert("runtime") %{
+#ifndef SWIG_V8_VERSION
+#define SWIG_V8_VERSION version
+#endif
+%}
+%enddef
+
+#ifdef V8_VERSION
+%swig_v8_define_version(V8_VERSION)
+#else
+// HACK: defining a default version
+%swig_v8_define_version(0x031110)
+#endif
+
+
+// Node support
+// ------------
+
+#ifdef BUILDING_NODE_EXTENSION
+%insert("runtime") %{
+#include <node.h>
+%}
+#endif
+
+
+// V8 runtime
+// ----------
+
+%insert(runtime) %{
+#include <v8.h>
+
+#include <errno.h>
+#include <limits.h>
+#include <stdlib.h>
+%}
+
+%insert(runtime) "swigrun.swg";         /* SWIG API */
+%insert(runtime) "swigerrors.swg";      /* SWIG errors */
+
+%insert(runtime) "javascriptrun.swg"
+
diff --git a/share/swig/3.0.12/javascript/v8/javascriptstrings.swg b/share/swig/3.0.12/javascript/v8/javascriptstrings.swg
new file mode 100644
index 0000000..65ba20e
--- /dev/null
+++ b/share/swig/3.0.12/javascript/v8/javascriptstrings.swg
@@ -0,0 +1,59 @@
+
+/* ------------------------------------------------------------
+ *  utility methods for char strings 
+ * ------------------------------------------------------------ */
+%fragment("SWIG_AsCharPtrAndSize", "header", fragment="SWIG_pchar_descriptor") {
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(v8::Handle<v8::Value> valRef, char** cptr, size_t* psize, int *alloc)
+{
+  if(valRef->IsString()) {
+    v8::Handle<v8::String> js_str = valRef->ToString();
+
+    size_t len = js_str->Utf8Length() + 1;
+    char* cstr = new char[len];
+    js_str->WriteUtf8(cstr, len);
+    
+    if(alloc) *alloc = SWIG_NEWOBJ;
+    if(psize) *psize = len;
+    if(cptr) *cptr = cstr;
+    
+    return SWIG_OK;
+  } else {
+    if(valRef->IsObject()) {
+      v8::Handle<v8::Object> obj = valRef->ToObject();
+      // try if the object is a wrapped char[]
+      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+      if (pchar_descriptor) {
+        void* vptr = 0;
+        if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
+          if (cptr) *cptr = (char *) vptr;
+          if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
+          if (alloc) *alloc = SWIG_OLDOBJ;
+          return SWIG_OK;
+        }
+      }
+      return SWIG_TypeError;
+    } else {
+      return SWIG_TypeError;
+    }
+  }
+}
+}
+
+%fragment("SWIG_FromCharPtrAndSize","header",fragment="SWIG_pchar_descriptor") {
+SWIGINTERNINLINE v8::Handle<v8::Value>
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+  if (carray) {
+    if (size > INT_MAX) {
+      // TODO: handle extra long strings
+      return SWIGV8_UNDEFINED();
+    } else {
+      v8::Handle<v8::String> js_str = SWIGV8_STRING_NEW2(carray, size);
+      return js_str;
+    }
+  } else {
+    return SWIGV8_UNDEFINED();
+  }
+}
+}
diff --git a/share/swig/3.0.12/javascript/v8/javascripttypemaps.swg b/share/swig/3.0.12/javascript/v8/javascripttypemaps.swg
new file mode 100644
index 0000000..4601698
--- /dev/null
+++ b/share/swig/3.0.12/javascript/v8/javascripttypemaps.swg
@@ -0,0 +1,43 @@
+/* ------------------------------------------------------------
+ *  Typemap specializations for Javascript
+ * ------------------------------------------------------------ */
+
+/* ------------------------------------------------------------
+ *  Fragment section
+ * ------------------------------------------------------------ */
+
+/* Include fundamental fragemt definitions */
+%include <typemaps/fragments.swg>
+
+/* Look for user fragments file. */
+%include <javascriptfragments.swg>
+
+/* Javascript fragments for fundamental types */
+%include <javascriptprimtypes.swg>
+
+/* Javascript fragments for char* strings */
+%include <javascriptstrings.swg>
+
+
+/* ------------------------------------------------------------
+ *  Unified typemap section
+ * ------------------------------------------------------------ */
+
+/* Javascript types */
+
+#define SWIG_Object                     v8::Handle<v8::Value>
+#define VOID_Object                     SWIGV8_UNDEFINED()
+
+/* Overload of the output/constant/exception/dirout handling */
+
+/* append output */
+#define SWIG_AppendOutput(result, obj) SWIGV8_AppendOutput(result, obj)
+
+/* set constant */
+#define SWIG_SetConstant(name, obj)
+
+/* raise */
+#define SWIG_Raise(obj, type, desc)  SWIG_V8_Raise(type)
+
+/* Include the unified typemap library */
+%include <typemaps/swigtypemaps.swg>
diff --git a/share/swig/3.0.12/javascript/v8/std_common.i b/share/swig/3.0.12/javascript/v8/std_common.i
new file mode 100644
index 0000000..cee11e8
--- /dev/null
+++ b/share/swig/3.0.12/javascript/v8/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/3.0.12/javascript/v8/std_complex.i b/share/swig/3.0.12/javascript/v8/std_complex.i
new file mode 100644
index 0000000..088a4fe
--- /dev/null
+++ b/share/swig/3.0.12/javascript/v8/std_complex.i
@@ -0,0 +1,19 @@
+/*
+ *  STD C++ complex typemaps
+ */
+
+%include <javascriptcomplex.swg>
+
+%{
+#include <complex> 
+%}
+
+/* defining the complex as/from converters */
+
+%swig_cplxdbl_convn(std::complex<double>, std::complex<double>, std::real, std::imag)
+%swig_cplxflt_convn(std::complex<float>,  std::complex<float>,  std::real, std::imag)
+
+/* defining the typemaps */
+
+%typemaps_primitive(%checkcode(CPLXDBL), std::complex<double>);
+%typemaps_primitive(%checkcode(CPLXFLT), std::complex<float>);
diff --git a/share/swig/2.0.11/mzscheme/std_deque.i b/share/swig/3.0.12/javascript/v8/std_deque.i
index cb98f6c..cb98f6c 100644
--- a/share/swig/2.0.11/mzscheme/std_deque.i
+++ b/share/swig/3.0.12/javascript/v8/std_deque.i
diff --git a/share/swig/2.0.11/perl5/std_except.i b/share/swig/3.0.12/javascript/v8/std_except.i
index af98428..af98428 100644
--- a/share/swig/2.0.11/perl5/std_except.i
+++ b/share/swig/3.0.12/javascript/v8/std_except.i
diff --git a/share/swig/3.0.12/javascript/v8/std_map.i b/share/swig/3.0.12/javascript/v8/std_map.i
new file mode 100644
index 0000000..e7812f3
--- /dev/null
+++ b/share/swig/3.0.12/javascript/v8/std_map.i
@@ -0,0 +1,74 @@
+/* -----------------------------------------------------------------------------
+ * 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();
+            }
+        }
+    };
+
+// 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/3.0.12/javascript/v8/std_pair.i b/share/swig/3.0.12/javascript/v8/std_pair.i
new file mode 100644
index 0000000..8d60572
--- /dev/null
+++ b/share/swig/3.0.12/javascript/v8/std_pair.i
@@ -0,0 +1,33 @@
+/* -----------------------------------------------------------------------------
+ * std_pair.i
+ *
+ * SWIG typemaps for std::pair
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.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/python/std_string.i b/share/swig/3.0.12/javascript/v8/std_string.i
index dc1378a..dc1378a 100644
--- a/share/swig/2.0.11/python/std_string.i
+++ b/share/swig/3.0.12/javascript/v8/std_string.i
diff --git a/share/swig/3.0.12/javascript/v8/std_vector.i b/share/swig/3.0.12/javascript/v8/std_vector.i
new file mode 100644
index 0000000..971b426
--- /dev/null
+++ b/share/swig/3.0.12/javascript/v8/std_vector.i
@@ -0,0 +1,85 @@
+/* -----------------------------------------------------------------------------
+ * std_vector.i
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.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 {
+            bool 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");
+            }
+        }
+    };
+}
+
+%define specialize_std_vector(T)
+#warning "specialize_std_vector - specialization for type T no longer needed"
+%enddef
+
diff --git a/share/swig/3.0.12/javascript/v8/stl.i b/share/swig/3.0.12/javascript/v8/stl.i
new file mode 100644
index 0000000..04f8601
--- /dev/null
+++ b/share/swig/3.0.12/javascript/v8/stl.i
@@ -0,0 +1,10 @@
+/* -----------------------------------------------------------------------------
+ * 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/3.0.12/javascript/v8/typemaps.i b/share/swig/3.0.12/javascript/v8/typemaps.i
new file mode 100644
index 0000000..d3d8afb
--- /dev/null
+++ b/share/swig/3.0.12/javascript/v8/typemaps.i
@@ -0,0 +1,148 @@
+/* -----------------------------------------------------------------------------
+ * typemaps.i
+ *
+ * Pointer handling
+ * These mappings provide support for input/output arguments and common
+ * uses for C/C++ pointers.
+ * ----------------------------------------------------------------------------- */
+
+// 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
+         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 Python tuple.
+
+         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
+         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);
+
+The Python output of the function would be a tuple containing both
+output values.
+
+*/
+
+// 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 Python 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
+         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);
+
+Unlike C, this mapping does not directly modify the input value (since
+this makes no sense in Python).  Rather, the modified input value shows
+up as the return value of the function.  Thus, to apply this function
+to a Python 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.
+
+*/
+
+%include <typemaps/typemaps.swg>
diff --git a/share/swig/2.0.11/lua/_std_common.i b/share/swig/3.0.12/lua/_std_common.i
index 567e68b..567e68b 100644
--- a/share/swig/2.0.11/lua/_std_common.i
+++ b/share/swig/3.0.12/lua/_std_common.i
diff --git a/share/swig/2.0.11/lua/carrays.i b/share/swig/3.0.12/lua/carrays.i
index 1bc45d8..1bc45d8 100644
--- a/share/swig/2.0.11/lua/carrays.i
+++ b/share/swig/3.0.12/lua/carrays.i
diff --git a/share/swig/2.0.11/lua/factory.i b/share/swig/3.0.12/lua/factory.i
index 7e605c5..7e605c5 100644
--- a/share/swig/2.0.11/lua/factory.i
+++ b/share/swig/3.0.12/lua/factory.i
diff --git a/share/swig/3.0.12/lua/lua.swg b/share/swig/3.0.12/lua/lua.swg
new file mode 100644
index 0000000..9c21d08
--- /dev/null
+++ b/share/swig/3.0.12/lua/lua.swg
@@ -0,0 +1,236 @@
+/* -----------------------------------------------------------------------------
+ * lua.swg
+ *
+ * SWIG Configuration File for Lua.
+ * This file is parsed by SWIG before reading any other interface file.
+ * ----------------------------------------------------------------------------- */
+
+/* -----------------------------------------------------------------------------
+ *                          includes
+ * ----------------------------------------------------------------------------- */
+
+%include <luatypemaps.swg>         /* The typemaps */
+%include <luaruntime.swg>          /* The runtime stuff */
+%include <luakw.swg>               /* Warnings for Lua keywords */
+
+//%include <typemaps/swigmacros.swg>
+/* -----------------------------------------------------------------------------
+ *                          constants typemaps
+ * ----------------------------------------------------------------------------- */
+// this basically adds to a table of constants
+%typemap(consttab) int, unsigned int, short, unsigned short, long, unsigned long, unsigned char, signed char, bool, enum SWIGTYPE
+       {SWIG_LUA_CONSTTAB_INT("$symname", $value)}
+
+%typemap(consttab) float, double
+       {SWIG_LUA_CONSTTAB_FLOAT("$symname", $value)}
+
+%typemap(consttab) long long, unsigned long long, signed long long
+       {SWIG_LUA_CONSTTAB_FLOAT("$symname", $value)}
+
+%typemap(consttab) const long long&, const unsigned long long&, const signed long long&
+       {SWIG_LUA_CONSTTAB_FLOAT("$symname", *$value)}
+
+%typemap(consttab) char *, const char *, char [], const char []
+       {SWIG_LUA_CONSTTAB_STRING("$symname", $value)}
+
+// note: char is treated as a seperate special type
+// signed char & unsigned char are numbers
+%typemap(consttab) char
+       {SWIG_LUA_CONSTTAB_CHAR("$symname", $value)}
+
+%typemap(consttab) long long, unsigned long long
+       {SWIG_LUA_CONSTTAB_STRING("$symname", "$value")}
+
+%typemap(consttab) SWIGTYPE *, SWIGTYPE *const, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE []
+       { SWIG_LUA_CONSTTAB_POINTER("$symname",$value, $1_descriptor) }
+
+%typemap(consttab) SWIGTYPE
+       { SWIG_LUA_CONSTTAB_POINTER("$symname",&$value, $&1_descriptor) }
+
+// member function pointers
+%typemap(consttab) SWIGTYPE (CLASS::*)
+       { SWIG_LUA_CONSTTAB_BINARY("$symname", sizeof($type),&$value, $1_descriptor) }
+
+
+/* -----------------------------------------------------------------------------
+ *                          Overloaded operator support
+ * ----------------------------------------------------------------------------- */
+// lua calls the + operator '__add'
+// python likes to call it '__add__'
+// Assuming most SWIGers will probably use the __add__ if they extend their classes
+// we have two sets of renames
+// one to rename the operator+() to __add()
+//	(this lets SWIG rename the operator overloads)
+// another is to rename __add__() to __add()
+//	(this means that people who wrote SWIG code to do that add will also work)
+
+#ifdef __cplusplus
+// this is extra renaming for lua
+// not all operators are supported, so only those that are, are listed
+%rename(__add)			*::operator+;
+%rename(__sub)			*::operator-;
+%rename(__mul)			*::operator*;
+%rename(__div)			*::operator/;
+%rename(__unm)      *::operator-();
+%rename(__unm)      *::operator-() const;
+
+%rename(__eq)			*::operator==;	
+%ignore *::operator!=;      // note: Lua does not have a notequal operator
+						// it just uses 'not (a==b)'
+%rename(__lt)			*::operator<;
+%ignore *::operator>;   	// ditto less than vs greater than
+%rename(__le)			*::operator<=;	
+%ignore *::operator>=;  // ditto less than vs greater than
+%ignore *::operator!;  // does not support not
+
+%rename(__call)			*::operator();	// the fn call operator
+
+// lua does not support overloading of:
+// 	logical/bitwise operators
+// 	assign operator
+// 	+=,-=,*=, etc
+// therefore ignoring them for now
+// it also doesn't support non class operators
+// eg friends or XX operator+(XX,XX)
+// also ignoring
+// note: some of these might be better to rename, but not doing that for now
+%ignore *::operator&&;	%ignore operator&&;
+%ignore *::operator||;	%ignore operator||;
+%ignore *::operator+=;
+%ignore *::operator-=;
+%ignore *::operator*=;
+%ignore *::operator/=;
+%ignore *::operator%=;
+%ignore *::operator++;	%ignore *::operator--;
+
+%ignore *::operator=;	// note: this might be better to rename to assign() or similar
+
+%ignore operator+;
+%ignore operator-;
+%ignore operator*;
+%ignore operator/;
+%ignore operator%;
+%ignore operator[];
+%ignore operator>;	%ignore operator>=;	
+%ignore operator<;	%ignore operator<=;
+%ignore operator==;	%ignore operator!=;
+
+
+// renaming the python operators to be compatible with lua
+// this means that if a developer has written a fn __add__()
+// it will be used for the lua +
+%rename(__add)			*::__add__;
+%rename(__sub)			*::__sub__;
+%rename(__mul)			*::__mul__;
+%rename(__div)			*::__div__;
+%rename(__unm)			*::__neg__;		// lua calls unary minus,'unm' not 'neg'
+%rename(__tostring)		*::__str__;		// both map to __tostring
+%rename(__tostring)		*::__repr__;	// both map to __tostring
+
+
+%rename(__pow)			*::__pow__;		// lua power '^' operator
+%rename(__concat)		*::__concat__;  // lua concat '..' operator
+%rename(__eq)			*::__eq__;
+%rename(__lt)			*::__lt__;
+%rename(__le)			*::__le__;
+%rename(__call)			*::__call__;	// the fn call operator()
+
+// the [] operator has two parts, the get & the set
+%rename(__getitem)			*::__getitem__;	// the v=X[i] (get operator)
+%rename(__setitem)			*::__setitem__;	// the X[i]=v (set operator)
+
+
+#endif
+
+
+/* ------------------------------------------------------------
+ *                              Exceptions
+ * ------------------------------------------------------------ */
+/* Confession: I don't really like C++ exceptions
+The python/lua ones are great, but C++ ones I don't like
+(mainly because I cannot get the stack trace out of it)
+Therefore I have not bothered to try doing much in this
+
+Therefore currently its just enough to get a few test cases running ok
+
+note: if you wish to throw anything related to std::exception
+use %include <std_except.i> instead
+*/
+
+// number as number+error
+%typemap(throws) int,unsigned int,signed int,
+				long,unsigned long,signed long,
+				short,unsigned short,signed short,
+				float,double,
+				long long,unsigned long long,
+				unsigned char, signed char,
+                int&,unsigned int&,signed int&,
+				long&,unsigned long&,signed long&,
+				short&,unsigned short&,signed short&,
+				float&,double&,
+				long long&,unsigned long long&,
+				unsigned char&, signed char&
+%{lua_pushnumber(L,(lua_Number)$1);SWIG_fail; %}
+
+%typemap(throws) bool,bool& 
+%{lua_pushboolean(L,(int)($1==true));SWIG_fail; %}
+
+// enum as number+error
+%typemap(throws) enum SWIGTYPE
+%{lua_pushnumber(L,(lua_Number)(int)$1);SWIG_fail; %}
+
+// strings are just sent as errors
+%typemap(throws) char *, const char *
+%{lua_pushstring(L,$1);SWIG_fail;%}
+
+// char is changed to a string
+%typemap(throws) char
+%{lua_pushlstring(L,&$1,1);SWIG_fail;%}
+
+/*
+Throwing object is a serious problem:
+Assuming some code throws a 'FooBar'
+There are a few options:
+- return a pointer to it: but its unclear how long this will last for.
+- return a copy of it: but not all objects are copyable
+	(see exception_partial_info in the test suite for a case where you cannot do this)
+- convert to a string & throw that
+	it's not so useful, but it works (this is more lua like).
+The third option (though not nice) is used
+For a more useful solution: see std_except for more details
+*/
+
+// basic typemap for structs, classes, pointers & references
+// convert to string and error
+%typemap(throws) SWIGTYPE
+%{(void)$1; /* ignore it */
+lua_pushfstring(L,"object exception:%s",SWIG_TypePrettyName($1_descriptor));
+SWIG_fail;%}
+
+// code to make a copy of the object and return this
+// if you have a function which throws a FooBar & you want SWIG to return a copy of the object as its error
+// then use one of the below
+//	%apply SWIGTYPE EXCEPTION_BY_VAL {FooBar};
+//	%apply SWIGTYPE& EXCEPTION_BY_VAL {FooBar&}; // note: need & twice
+%typemap(throws) SWIGTYPE EXCEPTION_BY_VAL
+%{SWIG_NewPointerObj(L,(void *)new $1_ltype(($1_ltype &) $1),$&1_descriptor,1);
+SWIG_fail;%}
+
+// similar for object reference
+// note: swig typemaps seem a little confused around here, therefore we use $basetype
+%typemap(throws) SWIGTYPE& EXCEPTION_BY_VAL
+%{SWIG_NewPointerObj(L,(void *)new $basetype($1),$1_descriptor,1);
+SWIG_fail;%}
+
+
+// note: no support for object pointers
+// its not clear how long the pointer is valid for, therefore not supporting it
+
+/* -----------------------------------------------------------------------------
+ *                          extras
+ * ----------------------------------------------------------------------------- */
+// this %define is to allow insertion of lua source code into the wrapper file
+#define %luacode  %insert("luacode")
+
+
+/* ------------------------------ end lua.swg  ------------------------------ */
diff --git a/share/swig/3.0.12/lua/lua_fnptr.i b/share/swig/3.0.12/lua/lua_fnptr.i
new file mode 100644
index 0000000..481cfaf
--- /dev/null
+++ b/share/swig/3.0.12/lua/lua_fnptr.i
@@ -0,0 +1,124 @@
+/* -----------------------------------------------------------------------------
+ * lua_fnptr.i
+ *
+ * SWIG Library file containing the main typemap code to support Lua modules.
+ * ----------------------------------------------------------------------------- */
+
+/* -----------------------------------------------------------------------------
+ *                          Basic function pointer support
+ * ----------------------------------------------------------------------------- */
+/*
+The structure: SWIGLUA_FN provides a simple (local only) wrapping for a function.
+
+For example if you wanted to have a C/C++ function take a lua function as a parameter.
+You could declare it as:
+  int my_func(int a, int b, SWIGLUA_FN fn);
+note: it should be passed by value, not byref or as a pointer.
+
+The SWIGLUA_FN holds a pointer to the lua_State, and the stack index where the function is held.
+The macro SWIGLUA_FN_GET() will put a copy of the lua function at the top of the stack.
+After that its fairly simple to write the rest of the code (assuming know how to use lua),
+just push the parameters, call the function and return the result.
+
+  int my_func(int a, int b, SWIGLUA_FN fn)
+  {
+    SWIGLUA_FN_GET(fn);
+    lua_pushnumber(fn.L,a);
+    lua_pushnumber(fn.L,b);
+    lua_call(fn.L,2,1);    // 2 in, 1 out
+    return luaL_checknumber(fn.L,-1);
+  }
+
+SWIG will automatically performs the wrapping of the arguments in and out.
+
+However: if you wish to store the function between calls, look to the SWIGLUA_REF below.
+
+*/
+// this is for the C code only, we don't want SWIG to wrapper it for us.
+%{
+typedef struct{
+  lua_State* L; /* the state */
+  int idx;      /* the index on the stack */
+}SWIGLUA_FN;
+
+#define SWIGLUA_FN_GET(fn) {lua_pushvalue(fn.L,fn.idx);}
+%}
+
+// the actual typemap
+%typemap(in,checkfn="lua_isfunction") SWIGLUA_FN
+%{  $1.L=L; $1.idx=$input; %}
+
+/* -----------------------------------------------------------------------------
+ *                          Storing lua object support
+ * ----------------------------------------------------------------------------- */
+/*
+The structure: SWIGLUA_REF provides a mechanism to store object (usually functions)
+between calls to the interpreter.
+
+For example if you wanted to have a C/C++ function take a lua function as a parameter.
+Then call it later, You could declare it as:
+  SWIGLUA_REF myref;
+  void set_func(SWIGLUA_REF ref);
+  SWIGLUA_REF get_func();
+  void call_func(int val);
+note: it should be passed by value, not byref or as a pointer.
+
+The SWIGLUA_REF holds a pointer to the lua_State, and an integer reference to the object.
+Because it holds a permanent ref to an object, the SWIGLUA_REF must be handled with a bit more care.
+It should be initialised to {0,0}. The function swiglua_ref_set() should be used to set it.
+swiglua_ref_clear() should be used to clear it when not in use, and swiglua_ref_get() to get the
+data back.
+
+Note: the typemap does not check that the object is in fact a function,
+if you need that you must add it yourself.
+
+
+  int my_func(int a, int b, SWIGLUA_FN fn)
+  {
+    SWIGLUA_FN_GET(fn);
+    lua_pushnumber(fn.L,a);
+    lua_pushnumber(fn.L,b);
+    lua_call(fn.L,2,1);    // 2 in, 1 out
+    return luaL_checknumber(fn.L,-1);
+  }
+
+SWIG will automatically performs the wrapping of the arguments in and out.
+
+However: if you wish to store the function between calls, look to the SWIGLUA_REF below.
+
+*/
+
+%{
+typedef struct{
+  lua_State* L; /* the state */
+  int ref;      /* a ref in the lua global index */
+}SWIGLUA_REF;
+
+
+void swiglua_ref_clear(SWIGLUA_REF* pref){
+ 	if (pref->L!=0 && pref->ref!=LUA_NOREF && pref->ref!=LUA_REFNIL){
+		luaL_unref(pref->L,LUA_REGISTRYINDEX,pref->ref);
+	}
+	pref->L=0; pref->ref=0;
+}
+
+void swiglua_ref_set(SWIGLUA_REF* pref,lua_State* L,int idx){
+	pref->L=L;
+	lua_pushvalue(L,idx);                 /* copy obj to top */
+	pref->ref=luaL_ref(L,LUA_REGISTRYINDEX); /* remove obj from top & put into registry */
+}
+
+void swiglua_ref_get(SWIGLUA_REF* pref){
+	if (pref->L!=0)
+		lua_rawgeti(pref->L,LUA_REGISTRYINDEX,pref->ref);
+}
+
+%}
+
+%typemap(in) SWIGLUA_REF
+%{  swiglua_ref_set(&$1,L,$input); %}
+
+%typemap(out) SWIGLUA_REF
+%{  if ($1.L!=0)  {swiglua_ref_get(&$1);} else {lua_pushnil(L);}
+  SWIG_arg++; %}
+
diff --git a/share/swig/3.0.12/lua/luakw.swg b/share/swig/3.0.12/lua/luakw.swg
new file mode 100644
index 0000000..fc2f92b
--- /dev/null
+++ b/share/swig/3.0.12/lua/luakw.swg
@@ -0,0 +1,67 @@
+/*
+  Warnings for Lua keywords, built-in names and bad names.
+*/
+
+#define LUAKW(x) %keywordwarn("'" `x` "' is a Lua keyword, renaming to 'c_" `x` "'", rename="c_%s")  `x`
+#define LUABN(x) %namewarn(%warningmsg(SWIGWARN_PARSE_BUILTIN_NAME, "'" `x` "' conflicts with a basic function in Lua"), %$not %$ismember)  `x`
+
+/*
+  Warnings for Lua keywords 
+  http://www.lua.org/manual/5.2/manual.html#3.1
+*/
+
+LUAKW(and);
+LUAKW(break);
+LUAKW(do);
+LUAKW(else);
+LUAKW(elseif);
+LUAKW(end);
+LUAKW(false);
+LUAKW(for);
+LUAKW(function);
+LUAKW(goto);
+LUAKW(if);
+LUAKW(in);
+LUAKW(local);
+LUAKW(nil);
+LUAKW(not);
+LUAKW(or);
+LUAKW(repeat);
+LUAKW(return);
+LUAKW(then);
+LUAKW(true);
+LUAKW(until);
+LUAKW(while);
+
+/*
+  Basic functions
+  http://www.lua.org/manual/5.2/manual.html#6.1
+*/ 
+
+LUABN(assert);
+LUABN(collectgarbage);
+LUABN(dofile);
+LUABN(error);
+LUABN(_G); // Not actually a function
+LUABN(getmetatable);
+LUABN(ipairs);
+LUABN(load);
+LUABN(loadfile);
+LUABN(next);
+LUABN(pairs);
+LUABN(pcall);
+LUABN(print);
+LUABN(rawequal);
+LUABN(rawget);
+LUABN(rawlen);
+LUABN(rawset);
+LUABN(select);
+LUABN(setmetatable);
+LUABN(tonumber);
+LUABN(tostring);
+LUABN(type);
+LUABN(_VERSION); // Not actually a function
+LUABN(xpcall);
+
+#undef LUABN
+#undef LUAKW
diff --git a/share/swig/3.0.12/lua/luarun.swg b/share/swig/3.0.12/lua/luarun.swg
new file mode 100644
index 0000000..660dbbf
--- /dev/null
+++ b/share/swig/3.0.12/lua/luarun.swg
@@ -0,0 +1,1934 @@
+/* -----------------------------------------------------------------------------
+ * luarun.swg
+ *
+ * This file contains the runtime support for Lua modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lua.h"
+#include "lauxlib.h"
+#include <stdlib.h>  /* for malloc */
+#include <assert.h>  /* for a few sanity tests */
+
+/* -----------------------------------------------------------------------------
+ * Lua flavors
+ * ----------------------------------------------------------------------------- */
+
+#define SWIG_LUA_FLAVOR_LUA 1
+#define SWIG_LUA_FLAVOR_ELUA 2
+#define SWIG_LUA_FLAVOR_ELUAC 3
+
+#if !defined(SWIG_LUA_TARGET)
+# error SWIG_LUA_TARGET not defined
+#endif
+
+#if defined(SWIG_LUA_ELUA_EMULATE)
+
+struct swig_elua_entry;
+
+typedef struct swig_elua_key {
+  int type;
+  union {
+    const char* strkey;
+    lua_Number numkey;
+  } key;
+} swig_elua_key;
+
+typedef struct swig_elua_val {
+  int type;
+  union {
+    lua_Number number;
+    const struct swig_elua_entry *table;
+    const char *string;
+    lua_CFunction function;
+    struct {
+      char member;
+      long lvalue;
+      void *pvalue;
+      swig_type_info **ptype;
+    } userdata;
+  } value;
+} swig_elua_val;
+
+typedef struct swig_elua_entry {
+  swig_elua_key key;
+  swig_elua_val value;
+} swig_elua_entry;
+
+#define LSTRKEY(x) {LUA_TSTRING, {.strkey = x} }
+#define LNUMKEY(x) {LUA_TNUMBER, {.numkey = x} }
+#define LNILKEY {LUA_TNIL, {.strkey = 0} }
+
+#define LNUMVAL(x) {LUA_TNUMBER, {.number = x} }
+#define LFUNCVAL(x) {LUA_TFUNCTION, {.function = x} }
+#define LROVAL(x) {LUA_TTABLE, {.table = x} }
+#define LNILVAL {LUA_TNIL, {.string = 0} }
+#define LSTRVAL(x) {LUA_TSTRING, {.string = x} }
+
+#define LUA_REG_TYPE swig_elua_entry
+
+#define SWIG_LUA_ELUA_EMUL_METATABLE_KEY "__metatable"
+
+#define lua_pushrotable(L,p)\
+  lua_newtable(L);\
+  assert(p);\
+  SWIG_Lua_elua_emulate_register(L,(swig_elua_entry*)(p));
+
+#define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\
+  LSTRKEY(B), {LUA_TUSERDATA, { .userdata={0,0,(void*)(C),&D} } }
+
+#define SWIG_LUA_CONSTTAB_BINARY(B,S,C,D)\
+  LSTRKEY(B), {LUA_TUSERDATA, { .userdata={1,S,(void*)(C),&D} } }
+#endif
+
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
+#  define SWIG_LUA_CONSTTAB_INT(B, C) LSTRKEY(B), LNUMVAL(C)
+#  define SWIG_LUA_CONSTTAB_FLOAT(B, C) LSTRKEY(B), LNUMVAL(C)
+#  define SWIG_LUA_CONSTTAB_STRING(B, C) LSTRKEY(B), LSTRVAL(C)
+#  define SWIG_LUA_CONSTTAB_CHAR(B, C) LSTRKEY(B), LNUMVAL(C)
+    /* Those two types of constants are not supported in elua */
+
+#ifndef SWIG_LUA_CONSTTAB_POINTER
+#warning eLua does not support pointers as constants. By default, nil will be used as value
+#define SWIG_LUA_CONSTTAB_POINTER(B,C,D) LSTRKEY(B), LNILVAL
+#endif
+
+#ifndef SWIG_LUA_CONSTTAB_BINARY
+#warning eLua does not support pointers to member as constants. By default, nil will be used as value
+#define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D) LSTRKEY(B), LNILVAL
+#endif
+#else /* SWIG_LUA_FLAVOR_LUA */
+#  define SWIG_LUA_CONSTTAB_INT(B, C) SWIG_LUA_INT, (char *)B, (long)C, 0, 0, 0
+#  define SWIG_LUA_CONSTTAB_FLOAT(B, C) SWIG_LUA_FLOAT, (char *)B, 0, (double)C, 0, 0
+#  define SWIG_LUA_CONSTTAB_STRING(B, C) SWIG_LUA_STRING, (char *)B, 0, 0, (void *)C, 0
+#  define SWIG_LUA_CONSTTAB_CHAR(B, C) SWIG_LUA_CHAR, (char *)B, (long)C, 0, 0, 0
+#  define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\
+       SWIG_LUA_POINTER, (char *)B, 0, 0, (void *)C, &D
+#  define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D)\
+       SWIG_LUA_BINARY,  (char *)B, S, 0, (void *)C, &D
+#endif
+
+#ifndef SWIG_LUA_ELUA_EMULATE
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
+#  define LRO_STRVAL(v) {{.p = (char *) v}, LUA_TSTRING}
+#  define LSTRVAL LRO_STRVAL
+#endif
+#endif /* SWIG_LUA_ELUA_EMULATE*/
+
+#ifndef SWIG_LUA_ELUA_EMULATE
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
+
+#ifndef MIN_OPT_LEVEL
+#define MIN_OPT_LEVEL 2
+#endif
+
+#include "lrodefs.h"
+#include "lrotable.h"
+#endif
+#endif /* SWIG_LUA_ELUA_EMULATE*/
+/* -----------------------------------------------------------------------------
+ * compatibility defines
+ * ----------------------------------------------------------------------------- */
+
+/* History of Lua C API length functions:  In Lua 5.0 (and before?)
+   there was "lua_strlen".  In Lua 5.1, this was renamed "lua_objlen",
+   but a compatibility define of "lua_strlen" was added.  In Lua 5.2,
+   this function was again renamed, to "lua_rawlen" (to emphasize that
+   it doesn't call the "__len" metamethod), and the compatibility
+   define of lua_strlen was removed.  All SWIG uses have been updated
+   to "lua_rawlen", and we add our own defines of that here for older
+   versions of Lua.  */
+#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 501
+# define lua_rawlen lua_strlen
+#elif LUA_VERSION_NUM == 501
+# define lua_rawlen lua_objlen
+#endif
+
+
+/* lua_pushglobaltable is the recommended "future-proof" way to get
+   the global table for Lua 5.2 and later.  Here we define
+   lua_pushglobaltable ourselves for Lua versions before 5.2.  */
+#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
+# define lua_pushglobaltable(L) lua_pushvalue(L, LUA_GLOBALSINDEX)
+#endif
+
+/* lua_absindex was introduced in Lua 5.2 */
+#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
+# define lua_absindex(L,i) ((i)>0 || (i) <= LUA_REGISTRYINDEX ? (i) : lua_gettop(L) + (i) + 1)
+#endif
+
+/* lua_rawsetp was introduced in Lua 5.2 */
+#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
+#define lua_rawsetp(L,index,ptr)\
+  lua_pushlightuserdata(L,(void*)(ptr));\
+  lua_insert(L,-2);\
+  lua_rawset(L,index);
+
+#define lua_rawgetp(L,index,ptr)\
+  lua_pushlightuserdata(L,(void*)(ptr));\
+  lua_rawget(L,index);
+
+#endif
+
+/* --------------------------------------------------------------------------
+ * Helper functions for error handling
+ * -------------------------------------------------------------------------- */
+
+/* Push the string STR on the Lua stack, like lua_pushstring, but
+   prefixed with the the location of the innermost Lua call-point
+   (as formated by luaL_where).  */
+SWIGRUNTIME void
+SWIG_Lua_pusherrstring (lua_State *L, const char *str)
+{
+  luaL_where (L, 1);
+  lua_pushstring (L, str);
+  lua_concat (L, 2);
+}
+
+/* Push a formatted string generated from FMT and following args on
+   the Lua stack, like lua_pushfstring, but prefixed with the the
+   location of the innermost Lua call-point (as formated by luaL_where).  */
+SWIGRUNTIME void
+SWIG_Lua_pushferrstring (lua_State *L, const char *fmt, ...)
+{
+  va_list argp;
+  va_start(argp, fmt);
+  luaL_where(L, 1);
+  lua_pushvfstring(L, fmt, argp);
+  va_end(argp);
+  lua_concat(L, 2);
+}
+
+
+/* -----------------------------------------------------------------------------
+ * global swig types
+ * ----------------------------------------------------------------------------- */
+/* Constant table */
+#define SWIG_LUA_INT     1
+#define SWIG_LUA_FLOAT   2
+#define SWIG_LUA_STRING  3
+#define SWIG_LUA_POINTER 4
+#define SWIG_LUA_BINARY  5
+#define SWIG_LUA_CHAR    6
+
+/* Structure for variable linking table */
+typedef struct {
+  const char *name;
+  lua_CFunction get;
+  lua_CFunction set;
+} swig_lua_var_info;
+
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
+typedef const LUA_REG_TYPE swig_lua_method;
+typedef const LUA_REG_TYPE swig_lua_const_info;
+#else /* Normal lua */
+typedef luaL_Reg swig_lua_method;
+
+/* Constant information structure */
+typedef struct {
+    int type;
+    char *name;
+    long lvalue;
+    double dvalue;
+    void   *pvalue;
+    swig_type_info **ptype;
+} swig_lua_const_info;
+
+#endif
+
+typedef struct {
+  const char     *name;
+  lua_CFunction   getmethod;
+  lua_CFunction   setmethod;
+} swig_lua_attribute;
+
+
+struct swig_lua_class;
+/* Can be used to create namespaces. Currently used to wrap class static methods/variables/constants */
+typedef struct swig_lua_namespace {
+  const char            *name;
+  swig_lua_method       *ns_methods;
+  swig_lua_attribute    *ns_attributes;
+  swig_lua_const_info   *ns_constants;
+  struct swig_lua_class        **ns_classes;
+  struct swig_lua_namespace    **ns_namespaces;
+} swig_lua_namespace;
+
+typedef struct swig_lua_class {
+  const char    *name; /* Name that this class has in Lua */
+  const char    *fqname; /* Fully qualified name - Scope + class name */
+  swig_type_info   **type;
+  lua_CFunction  constructor;
+  void    (*destructor)(void *);
+  swig_lua_method   *methods;
+  swig_lua_attribute     *attributes;
+  swig_lua_namespace    *cls_static;
+  swig_lua_method   *metatable; /* 0 for -eluac */
+  struct swig_lua_class **bases;
+  const char **base_names;
+} swig_lua_class;
+
+/* this is the struct for wrapping all pointers in SwigLua
+*/
+typedef struct {
+  swig_type_info   *type;
+  int     own;  /* 1 if owned & must be destroyed */
+  void        *ptr;
+} swig_lua_userdata;
+
+/* this is the struct for wrapping arbitrary packed binary data
+(currently it is only used for member function pointers)
+the data ordering is similar to swig_lua_userdata, but it is currently not possible
+to tell the two structures apart within SWIG, other than by looking at the type
+*/
+typedef struct {
+  swig_type_info   *type;
+  int     own;  /* 1 if owned & must be destroyed */
+  char data[1];       /* arbitary amount of data */    
+} swig_lua_rawdata;
+
+/* Common SWIG API */
+#define SWIG_NewPointerObj(L, ptr, type, owner)       SWIG_Lua_NewPointerObj(L, (void *)ptr, type, owner)
+#define SWIG_ConvertPtr(L,idx, ptr, type, flags)    SWIG_Lua_ConvertPtr(L,idx,ptr,type,flags)
+#define SWIG_MustGetPtr(L,idx, type,flags, argnum,fnname)  SWIG_Lua_MustGetPtr(L,idx, type,flags, argnum,fnname)
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(L, idx, ptr, sz, ty)       SWIG_Lua_ConvertPacked(L, idx, ptr, sz, ty)
+#define SWIG_NewMemberObj(L, ptr, sz, type)      SWIG_Lua_NewPackedObj(L, ptr, sz, type)
+
+/* Runtime API */
+#define SWIG_GetModule(clientdata) SWIG_Lua_GetModule((lua_State*)(clientdata))
+#define SWIG_SetModule(clientdata, pointer) SWIG_Lua_SetModule((lua_State*) (clientdata), pointer)
+#define SWIG_MODULE_CLIENTDATA_TYPE lua_State*
+
+/* Contract support */
+#define SWIG_contract_assert(expr, msg)  \
+  if (!(expr)) { SWIG_Lua_pusherrstring(L, (char *) msg); goto fail; } else
+
+
+/* helper #defines */
+#define SWIG_fail {goto fail;}
+#define SWIG_fail_arg(func_name,argnum,type) \
+  {SWIG_Lua_pushferrstring(L,"Error in %s (arg %d), expected '%s' got '%s'",\
+  func_name,argnum,type,SWIG_Lua_typename(L,argnum));\
+  goto fail;}
+#define SWIG_fail_ptr(func_name,argnum,type) \
+  SWIG_fail_arg(func_name,argnum,(type && type->str)?type->str:"void*")
+#define SWIG_check_num_args(func_name,a,b) \
+  if (lua_gettop(L)<a || lua_gettop(L)>b) \
+  {SWIG_Lua_pushferrstring(L,"Error in %s expected %d..%d args, got %d",func_name,a,b,lua_gettop(L));\
+  goto fail;}
+
+
+#define SWIG_Lua_get_table(L,n) \
+  (lua_pushstring(L, n), lua_rawget(L,-2))
+
+#define SWIG_Lua_add_function(L,n,f) \
+  (lua_pushstring(L, n), \
+      lua_pushcfunction(L, f), \
+      lua_rawset(L,-3))
+
+#define SWIG_Lua_add_boolean(L,n,b) \
+  (lua_pushstring(L, n), \
+      lua_pushboolean(L, b), \
+      lua_rawset(L,-3))
+
+/* special helper for allowing 'nil' for usertypes */
+#define SWIG_isptrtype(L,I) (lua_isuserdata(L,I) || lua_isnil(L,I))
+
+#ifdef __cplusplus
+/* Special helper for member function pointers 
+it gets the address, casts it, then dereferences it */
+/*#define SWIG_mem_fn_as_voidptr(a)  (*((char**)&(a))) */
+#endif
+
+/* storing/access of swig_module_info */
+SWIGRUNTIME swig_module_info *
+SWIG_Lua_GetModule(lua_State *L) {
+  swig_module_info *ret = 0;
+  lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  lua_rawget(L,LUA_REGISTRYINDEX);
+  if (lua_islightuserdata(L,-1))
+    ret=(swig_module_info*)lua_touserdata(L,-1);
+  lua_pop(L,1);  /* tidy */
+  return ret;
+}
+
+SWIGRUNTIME void
+SWIG_Lua_SetModule(lua_State *L, swig_module_info *module) {
+  /* add this all into the Lua registry: */
+  lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  lua_pushlightuserdata(L,(void*)module);
+  lua_rawset(L,LUA_REGISTRYINDEX);
+}
+
+/* -----------------------------------------------------------------------------
+ * global variable support code: modules
+ * ----------------------------------------------------------------------------- */
+
+/* this function is called when trying to set an immutable.
+default action is to print an error.
+This can removed with a compile flag SWIGLUA_IGNORE_SET_IMMUTABLE */
+SWIGINTERN int SWIG_Lua_set_immutable(lua_State *L)
+{
+/*  there should be 1 param passed in: the new value */
+#ifndef SWIGLUA_IGNORE_SET_IMMUTABLE
+  lua_pop(L,1);  /* remove it */
+  luaL_error(L,"This variable is immutable");
+#endif
+    return 0;   /* should not return anything */
+}
+
+#ifdef SWIG_LUA_ELUA_EMULATE
+
+SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own);
+SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type);
+static int swig_lua_elua_emulate_unique_key;
+
+/* This function emulates eLua rotables behaviour. It loads a rotable definition into the usual lua table. */
+SWIGINTERN void SWIG_Lua_elua_emulate_register(lua_State *L, const swig_elua_entry *table)
+{
+  int i, table_parsed, parsed_tables_array, target_table;
+  assert(lua_istable(L,-1));
+  target_table = lua_gettop(L);
+  /* Get the registry where we put all parsed tables to avoid loops */
+  lua_rawgetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key);
+  if(lua_isnil(L,-1)) {
+    lua_pop(L,1);
+    lua_newtable(L);
+    lua_pushvalue(L,-1);
+    lua_rawsetp(L,LUA_REGISTRYINDEX,(void*)(&swig_lua_elua_emulate_unique_key));
+  }
+  parsed_tables_array = lua_gettop(L);
+  lua_pushvalue(L,target_table);
+  lua_rawsetp(L, parsed_tables_array, table);
+  table_parsed = 0;
+  const int SWIGUNUSED pairs_start = lua_gettop(L);
+  for(i = 0;table[i].key.type != LUA_TNIL || table[i].value.type != LUA_TNIL;i++)
+  {
+    const swig_elua_entry *entry = table + i;
+    int is_metatable = 0;
+    switch(entry->key.type) {
+      case LUA_TSTRING:
+        lua_pushstring(L,entry->key.key.strkey);
+        if(strcmp(entry->key.key.strkey, SWIG_LUA_ELUA_EMUL_METATABLE_KEY) == 0)
+          is_metatable = 1;
+        break;
+      case  LUA_TNUMBER:
+        lua_pushnumber(L,entry->key.key.numkey);
+        break;
+      case LUA_TNIL:
+        lua_pushnil(L);
+        break;
+      default:
+        assert(0);
+    }
+    switch(entry->value.type) {
+      case LUA_TSTRING:
+        lua_pushstring(L,entry->value.value.string);
+        break;
+      case  LUA_TNUMBER:
+        lua_pushnumber(L,entry->value.value.number);
+        break;
+      case LUA_TFUNCTION:
+        lua_pushcfunction(L,entry->value.value.function);
+        break;
+      case LUA_TTABLE:
+        lua_rawgetp(L,parsed_tables_array, entry->value.value.table);
+        table_parsed = !lua_isnil(L,-1);
+        if(!table_parsed) {
+          lua_pop(L,1); /*remove nil */
+          lua_newtable(L);
+          SWIG_Lua_elua_emulate_register(L,entry->value.value.table);
+        } 
+        if(is_metatable) {
+          assert(lua_istable(L,-1));
+          lua_pushvalue(L,-1);
+          lua_setmetatable(L,target_table);
+        }
+
+        break;
+      case LUA_TUSERDATA:
+        if(entry->value.value.userdata.member) 
+          SWIG_NewMemberObj(L,entry->value.value.userdata.pvalue,
+              entry->value.value.userdata.lvalue,
+              *(entry->value.value.userdata.ptype));
+        else 
+          SWIG_NewPointerObj(L,entry->value.value.userdata.pvalue,
+              *(entry->value.value.userdata.ptype),0);
+        break;
+      case LUA_TNIL:
+        lua_pushnil(L);
+        break;
+      default:
+        assert(0);
+    }
+    assert(lua_gettop(L) == pairs_start + 2);
+    lua_rawset(L,target_table);
+  }
+  lua_pop(L,1); /* Removing parsed tables storage */
+  assert(lua_gettop(L) == target_table);
+}
+
+SWIGINTERN void SWIG_Lua_elua_emulate_register_clear(lua_State *L)
+{
+  lua_pushnil(L);
+  lua_rawsetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key);
+}
+
+SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L);
+
+SWIGINTERN int SWIG_Lua_emulate_elua_getmetatable(lua_State *L)
+{
+  SWIG_check_num_args("getmetatable(SWIG eLua emulation)", 1, 1);
+  SWIG_Lua_get_class_registry(L);
+  lua_getfield(L,-1,"lua_getmetatable");
+  lua_remove(L,-2); /* remove the registry*/
+  assert(!lua_isnil(L,-1));
+  lua_pushvalue(L,1);
+  assert(lua_gettop(L) == 3); /* object | function | object again */
+  lua_call(L,1,1);
+  if(!lua_isnil(L,-1)) /*There is an ordinary metatable */
+    return 1;
+  /*if it is a table, then emulate elua behaviour - check for __metatable attribute of a table*/
+  assert(lua_gettop(L) == 2);
+  if(lua_istable(L,-2)) {
+    lua_pop(L,1); /*remove the nil*/
+    lua_getfield(L,-1, SWIG_LUA_ELUA_EMUL_METATABLE_KEY);
+  }
+  assert(lua_gettop(L) == 2);
+  return 1;
+  
+fail:
+  lua_error(L);
+  return 0;
+}
+
+SWIGINTERN void SWIG_Lua_emulate_elua_swap_getmetatable(lua_State *L)
+{
+  SWIG_Lua_get_class_registry(L);
+  lua_pushglobaltable(L);
+  lua_pushstring(L,"lua_getmetatable");
+  lua_getfield(L,-2,"getmetatable");
+  assert(!lua_isnil(L,-1));
+  lua_rawset(L,-4);
+  lua_pushstring(L, "getmetatable");
+  lua_pushcfunction(L, SWIG_Lua_emulate_elua_getmetatable);
+  lua_rawset(L,-3);
+  lua_pop(L,2);
+      
+}
+/* END OF REMOVE */
+
+#endif
+/* -----------------------------------------------------------------------------
+ * global variable support code: namespaces and modules (which are the same thing)
+ * ----------------------------------------------------------------------------- */
+
+SWIGINTERN int SWIG_Lua_namespace_get(lua_State *L)
+{
+/*  there should be 2 params passed in
+  (1) table (not the meta table)
+  (2) string name of the attribute
+*/
+  assert(lua_istable(L,-2));  /* just in case */
+  lua_getmetatable(L,-2);
+  assert(lua_istable(L,-1));
+  SWIG_Lua_get_table(L,".get"); /* find the .get table */
+  assert(lua_istable(L,-1));
+  /* look for the key in the .get table */
+  lua_pushvalue(L,2);  /* key */
+  lua_rawget(L,-2);
+  lua_remove(L,-2); /* stack tidy, remove .get table */
+  if (lua_iscfunction(L,-1))
+  {  /* found it so call the fn & return its value */
+    lua_call(L,0,1);  /* 1 value in (userdata),1 out (result) */
+    lua_remove(L,-2); /* stack tidy, remove metatable */
+    return 1;
+  }
+  lua_pop(L,1);  /* remove whatever was there */
+  /* ok, so try the .fn table */
+  SWIG_Lua_get_table(L,".fn"); /* find the .get table */
+  assert(lua_istable(L,-1));  /* just in case */
+  lua_pushvalue(L,2);  /* key */
+  lua_rawget(L,-2);  /* look for the fn */
+  lua_remove(L,-2); /* stack tidy, remove .fn table */
+  if (lua_isfunction(L,-1)) /* note: whether it's a C function or lua function */
+  {  /* found it so return the fn & let lua call it */
+    lua_remove(L,-2); /* stack tidy, remove metatable */
+    return 1;
+  }
+  lua_pop(L,1);  /* remove whatever was there */
+  return 0;
+}
+
+SWIGINTERN int SWIG_Lua_namespace_set(lua_State *L)
+{
+/*  there should be 3 params passed in
+  (1) table (not the meta table)
+  (2) string name of the attribute
+  (3) any for the new value
+*/
+
+  assert(lua_istable(L,1));
+  lua_getmetatable(L,1);    /* get the meta table */
+  assert(lua_istable(L,-1));
+
+  SWIG_Lua_get_table(L,".set"); /* find the .set table */
+  if (lua_istable(L,-1))
+  {
+    /* look for the key in the .set table */
+    lua_pushvalue(L,2);  /* key */
+    lua_rawget(L,-2);
+    if (lua_iscfunction(L,-1))
+    {  /* found it so call the fn & return its value */
+      lua_pushvalue(L,3);  /* value */
+      lua_call(L,1,0);
+      return 0;
+    }
+    lua_pop(L,1);  /* remove the value */
+  }
+  lua_pop(L,1);  /* remove the value .set table */
+  lua_pop(L,1); /* remote metatable */
+  lua_rawset(L,-3);
+  return 0;
+}
+
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */
+SWIGINTERN void SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]); /* forward declaration */
+SWIGINTERN void  SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn); /* forward declaration */
+SWIGINTERN void  SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss);
+
+/* helper function - register namespace methods and attributes into namespace */
+SWIGINTERN int SWIG_Lua_add_namespace_details(lua_State *L, swig_lua_namespace *ns)
+{
+  int i;
+  /* There must be namespace table (not metatable) at the top of the stack */
+  assert(lua_istable(L,-1));
+  SWIG_Lua_InstallConstants(L, ns->ns_constants);
+
+  /* add methods to the namespace/module table */
+  for(i=0;ns->ns_methods[i].name;i++){
+    SWIG_Lua_add_function(L,ns->ns_methods[i].name,ns->ns_methods[i].func);
+  }
+  lua_getmetatable(L,-1);
+
+  /* add fns */
+  for(i=0;ns->ns_attributes[i].name;i++){
+    SWIG_Lua_add_variable(L,ns->ns_attributes[i].name,ns->ns_attributes[i].getmethod,ns->ns_attributes[i].setmethod);
+  }
+
+  /* clear stack - remove metatble */
+  lua_pop(L,1);
+  return 0;
+}
+
+/* Register all classes in the namespace */
+SWIGINTERN void SWIG_Lua_add_namespace_classes(lua_State *L, swig_lua_namespace *ns)
+{
+  swig_lua_class **classes;
+
+  /* There must be a module/namespace table at the top of the stack */
+  assert(lua_istable(L,-1));
+
+  classes = ns->ns_classes;
+
+  if( classes != 0 ) {
+    while(*classes != 0) {
+      SWIG_Lua_class_register(L, *classes);
+      classes++;
+    }
+  }
+}
+
+/* Helper function. Creates namespace table and adds it to module table
+   if 'reg' is true, then will register namespace table to parent one (must be on top of the stack
+   when function is called).
+   Function always returns newly registered table on top of the stack.
+*/
+SWIGINTERN void SWIG_Lua_namespace_register(lua_State *L, swig_lua_namespace *ns, int reg)
+{
+  swig_lua_namespace **sub_namespace;
+  /* 1 argument - table on the top of the stack */
+  const int SWIGUNUSED begin = lua_gettop(L);
+  assert(lua_istable(L,-1)); /* just in case. This is supposed to be module table or parent namespace table */
+  lua_checkstack(L,5);
+  lua_newtable(L); /* namespace itself */
+  lua_newtable(L); /* metatable for namespace */
+
+  /* add a table called ".get" */
+  lua_pushstring(L,".get");
+  lua_newtable(L);
+  lua_rawset(L,-3);
+  /* add a table called ".set" */
+  lua_pushstring(L,".set");
+  lua_newtable(L);
+  lua_rawset(L,-3);
+  /* add a table called ".fn" */
+  lua_pushstring(L,".fn");
+  lua_newtable(L);
+  lua_rawset(L,-3);
+
+  /* add accessor fns for using the .get,.set&.fn */
+  SWIG_Lua_add_function(L,"__index",SWIG_Lua_namespace_get);
+  SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_namespace_set);
+
+  lua_setmetatable(L,-2); /* set metatable */
+
+  /* Register all functions, variables etc */
+  SWIG_Lua_add_namespace_details(L,ns);
+  /* Register classes */
+  SWIG_Lua_add_namespace_classes(L,ns);
+
+  sub_namespace = ns->ns_namespaces;
+  if( sub_namespace != 0) {
+    while(*sub_namespace != 0) {
+      SWIG_Lua_namespace_register(L, *sub_namespace, 1);
+      lua_pop(L,1); /* removing sub-namespace table */
+      sub_namespace++;
+    }
+  }
+
+  if (reg) {
+    lua_pushstring(L,ns->name);
+    lua_pushvalue(L,-2);
+    lua_rawset(L,-4); /* add namespace to module table */
+  }
+  assert(lua_gettop(L) == begin+1);
+}
+#endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */
+
+/* -----------------------------------------------------------------------------
+ * global variable support code: classes
+ * ----------------------------------------------------------------------------- */
+
+SWIGINTERN void  SWIG_Lua_get_class_metatable(lua_State *L,const char *cname);
+
+typedef int (*swig_lua_base_iterator_func)(lua_State*,swig_type_info*, int, int *ret);
+
+SWIGINTERN int SWIG_Lua_iterate_bases(lua_State *L, swig_type_info * SWIGUNUSED swig_type,
+  int first_arg, swig_lua_base_iterator_func func, int  *const ret)
+{
+    /* first_arg - position of the object in stack. Everything that is above are arguments
+     * and is passed to every evocation of the func */
+    int last_arg = lua_gettop(L);/* position of last argument */
+    int original_metatable = last_arg + 1;
+    size_t bases_count;
+    int result = SWIG_ERROR;
+    int bases_table;
+    (void)swig_type;
+    lua_getmetatable(L,first_arg);
+
+    /* initialise base search */
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
+    SWIG_Lua_get_table(L,".bases");
+    assert(lua_istable(L,-1));
+    bases_count = lua_rawlen(L,-1);
+    bases_table = lua_gettop(L);
+#else
+    /* In elua .bases table doesn't exist. Use table from swig_lua_class */
+    (void)bases_table;
+    assert(swig_type!=0);
+    swig_module_info *module=SWIG_GetModule(L);
+    swig_lua_class **bases= ((swig_lua_class*)(swig_type->clientdata))->bases;
+    const char **base_names= ((swig_lua_class*)(swig_type->clientdata))->base_names;
+    bases_count = 0;
+    for(;base_names[bases_count];
+      bases_count++);/* get length of bases */
+#endif
+
+    if(ret)
+      *ret = 0;
+    if(bases_count>0)
+    {
+      int to_remove;
+      size_t i;
+      int j;
+      int subcall_last_arg;
+      int subcall_first_arg = lua_gettop(L) + 1;/* Here a copy of first_arg and arguments begin */
+      int valid = 1;
+      swig_type_info *base_swig_type = 0;
+      for(j=first_arg;j<=last_arg;j++)
+        lua_pushvalue(L,j);
+      subcall_last_arg = lua_gettop(L);
+
+      /* Trick: temporarily replacing original metatable with metatable for base class and call getter */
+      for(i=0;i<bases_count;i++) {
+        /* Iteration through class bases */
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
+        lua_rawgeti(L,bases_table,i+1);
+        base_swig_type = 0;
+        if(lua_isnil(L,-1)) {
+          valid = 0;
+          lua_pop(L,1);
+        } else {
+          valid = 1;
+        }
+#else /* In elua .bases table doesn't exist. Use table from swig_lua_class */
+        swig_lua_class *base_class = bases[i];
+        if(!base_class) {
+          valid = 0;
+        } else {
+          valid = 1;
+          SWIG_Lua_get_class_metatable(L,base_class->fqname);
+          base_swig_type = SWIG_TypeQueryModule(module,module,base_names[i]);
+          assert(base_swig_type != 0);
+        }
+#endif
+
+        if(!valid)
+          continue;
+        assert(lua_isuserdata(L, subcall_first_arg));
+        assert(lua_istable(L,-1));
+        lua_setmetatable(L,subcall_first_arg); /* Set new metatable */
+        assert(lua_gettop(L) == subcall_last_arg);
+        result = func(L, base_swig_type,subcall_first_arg, ret); /* Forward call */
+        if(result != SWIG_ERROR) {
+          break;
+        }
+      }
+      /* Restore original metatable */
+      lua_pushvalue(L,original_metatable);
+      lua_setmetatable(L,first_arg);
+      /* Clear - remove everything between last_arg and subcall_last_arg including */
+      to_remove = subcall_last_arg - last_arg;
+      for(j=0;j<to_remove;j++)
+        lua_remove(L,last_arg+1);
+    } else {
+      /* Remove everything after last_arg */
+      lua_pop(L, lua_gettop(L) - last_arg);
+    }
+    if(ret) assert(lua_gettop(L) == last_arg + *ret);
+    return result;
+}
+
+/* The class.get method helper, performs the lookup of class attributes.
+ * It returns an error code. Number of function return values is passed inside 'ret'.
+ * first_arg is not used in this function because function always has 2 arguments.
+ */
+SWIGINTERN int  SWIG_Lua_class_do_get_item(lua_State *L, swig_type_info *type, int SWIGUNUSED first_arg, int *ret)
+{
+/*  there should be 2 params passed in
+  (1) userdata (not the meta table)
+  (2) string name of the attribute
+*/
+  int bases_search_result;
+  int substack_start = lua_gettop(L)-2;
+  assert(first_arg == substack_start+1);
+  lua_checkstack(L,5);
+  assert(lua_isuserdata(L,-2));  /* just in case */
+  lua_getmetatable(L,-2);    /* get the meta table */
+  assert(lua_istable(L,-1));  /* just in case */
+  /* NEW: looks for the __getitem() fn
+  this is a user provided get fn */
+  SWIG_Lua_get_table(L,"__getitem"); /* find the __getitem fn */
+  if (lua_iscfunction(L,-1))  /* if its there */
+  {  /* found it so call the fn & return its value */
+    lua_pushvalue(L,substack_start+1);  /* the userdata */
+    lua_pushvalue(L,substack_start+2);  /* the parameter */
+    lua_call(L,2,1);  /* 2 value in (userdata),1 out (result) */
+    lua_remove(L,-2); /* stack tidy, remove metatable */
+    if(ret) *ret = 1;
+    return SWIG_OK;
+  }
+  lua_pop(L,1);
+  /* Remove the metatable */
+  lua_pop(L,1);
+  /* Search in base classes */
+  bases_search_result = SWIG_Lua_iterate_bases(L,type,substack_start+1,SWIG_Lua_class_do_get_item,ret);
+  return bases_search_result;  /* sorry not known */
+}
+
+
+/* The class.get method helper, performs the lookup of class attributes.
+ * It returns an error code. Number of function return values is passed inside 'ret'.
+ * first_arg is not used in this function because function always has 2 arguments.
+ */
+SWIGINTERN int  SWIG_Lua_class_do_get(lua_State *L, swig_type_info *type, int SWIGUNUSED first_arg, int *ret)
+{
+/*  there should be 2 params passed in
+  (1) userdata (not the meta table)
+  (2) string name of the attribute
+*/
+  int bases_search_result;
+  int substack_start = lua_gettop(L)-2;
+  assert(first_arg == substack_start+1);
+  lua_checkstack(L,5);
+  assert(lua_isuserdata(L,-2));  /* just in case */
+  lua_getmetatable(L,-2);    /* get the meta table */
+  assert(lua_istable(L,-1));  /* just in case */
+  SWIG_Lua_get_table(L,".get"); /* find the .get table */
+  assert(lua_istable(L,-1));  /* just in case */
+  /* look for the key in the .get table */
+  lua_pushvalue(L,substack_start+2);  /* key */
+  lua_rawget(L,-2);
+  lua_remove(L,-2); /* stack tidy, remove .get table */
+  if (lua_iscfunction(L,-1))
+  {  /* found it so call the fn & return its value */
+    lua_pushvalue(L,substack_start+1);  /* the userdata */
+    lua_call(L,1,1);  /* 1 value in (userdata),1 out (result) */
+    lua_remove(L,-2); /* stack tidy, remove metatable */
+    if(ret)
+      *ret = 1;
+    return SWIG_OK;
+  }
+  lua_pop(L,1);  /* remove whatever was there */
+  /* ok, so try the .fn table */
+  SWIG_Lua_get_table(L,".fn"); /* find the .fn table */
+  assert(lua_istable(L,-1));  /* just in case */
+  lua_pushvalue(L,substack_start+2);  /* key */
+  lua_rawget(L,-2);  /* look for the fn */
+  lua_remove(L,-2); /* stack tidy, remove .fn table */
+  if (lua_isfunction(L,-1)) /* note: if its a C function or lua function */
+  {  /* found it so return the fn & let lua call it */
+    lua_remove(L,-2); /* stack tidy, remove metatable */
+    if(ret)
+      *ret = 1;
+    return SWIG_OK;
+  }
+  lua_pop(L,1);  /* remove whatever was there */
+  /* Remove the metatable */
+  lua_pop(L,1);
+  /* Search in base classes */
+  bases_search_result = SWIG_Lua_iterate_bases(L,type,substack_start+1,SWIG_Lua_class_do_get,ret);
+  return bases_search_result;  /* sorry not known */
+}
+
+/* the class.get method, performs the lookup of class attributes
+ */
+SWIGINTERN int  SWIG_Lua_class_get(lua_State *L)
+{
+/*  there should be 2 params passed in
+  (1) userdata (not the meta table)
+  (2) string name of the attribute
+*/
+  int result;
+  swig_lua_userdata *usr;
+  swig_type_info *type;
+  int ret = 0;
+  assert(lua_isuserdata(L,1));
+  usr=(swig_lua_userdata*)lua_touserdata(L,1);  /* get data */
+  type = usr->type;
+  result = SWIG_Lua_class_do_get(L,type,1,&ret);
+  if(result == SWIG_OK)
+    return ret;
+
+  result = SWIG_Lua_class_do_get_item(L,type,1,&ret);
+  if(result == SWIG_OK)
+    return ret;
+
+  return 0;
+}
+
+/* helper for the class.set method, performs the lookup of class attributes
+ * It returns error code. Number of function return values is passed inside 'ret'
+ */
+SWIGINTERN int  SWIG_Lua_class_do_set(lua_State *L, swig_type_info *type, int first_arg, int *ret)
+{
+/*  there should be 3 params passed in
+  (1) table (not the meta table)
+  (2) string name of the attribute
+  (3) any for the new value
+  */
+
+  int bases_search_result;
+  int substack_start = lua_gettop(L) - 3;
+  lua_checkstack(L,5);
+  assert(lua_isuserdata(L,substack_start+1));  /* just in case */
+  lua_getmetatable(L,substack_start+1);    /* get the meta table */
+  assert(lua_istable(L,-1));  /* just in case */
+  if(ret)
+    *ret = 0; /* it is setter - number of return values is always 0 */
+
+  SWIG_Lua_get_table(L,".set"); /* find the .set table */
+  if (lua_istable(L,-1))
+  {
+    /* look for the key in the .set table */
+    lua_pushvalue(L,substack_start+2);  /* key */
+    lua_rawget(L,-2);
+    lua_remove(L,-2); /* tidy stack, remove .set table */
+    if (lua_iscfunction(L,-1))
+    {  /* found it so call the fn & return its value */
+      lua_pushvalue(L,substack_start+1);  /* userdata */
+      lua_pushvalue(L,substack_start+3);  /* value */
+      lua_call(L,2,0);
+      lua_remove(L,substack_start+4); /*remove metatable*/
+      return SWIG_OK;
+    }
+    lua_pop(L,1);  /* remove the value */
+  } else {
+    lua_pop(L,1);  /* remove the answer for .set table request*/
+  }
+  /* NEW: looks for the __setitem() fn
+  this is a user provided set fn */
+  SWIG_Lua_get_table(L,"__setitem"); /* find the fn */
+  if (lua_iscfunction(L,-1))  /* if its there */
+  {  /* found it so call the fn & return its value */
+    lua_pushvalue(L,substack_start+1);  /* the userdata */
+    lua_pushvalue(L,substack_start+2);  /* the parameter */
+    lua_pushvalue(L,substack_start+3);  /* the value */
+    lua_call(L,3,0);  /* 3 values in ,0 out */
+    lua_remove(L,-2); /* stack tidy, remove metatable */
+    return SWIG_OK;
+  }
+  lua_pop(L,1); /* remove value */
+
+  lua_pop(L,1); /* remove metatable */
+  /* Search among bases */
+  bases_search_result = SWIG_Lua_iterate_bases(L,type,first_arg,SWIG_Lua_class_do_set,ret);
+  if(ret)
+    assert(*ret == 0);
+  assert(lua_gettop(L) == substack_start + 3);
+  return bases_search_result;
+}
+
+/* This is the actual method exported to Lua. It calls SWIG_Lua_class_do_set and correctly
+ * handles return values.
+ */
+SWIGINTERN int  SWIG_Lua_class_set(lua_State *L)
+{
+/*  There should be 3 params passed in
+  (1) table (not the meta table)
+  (2) string name of the attribute
+  (3) any for the new value
+  */
+  int ret = 0;
+  int result;
+  swig_lua_userdata *usr;
+  swig_type_info *type;
+  assert(lua_isuserdata(L,1));
+  usr=(swig_lua_userdata*)lua_touserdata(L,1);  /* get data */
+  type = usr->type;
+  result = SWIG_Lua_class_do_set(L,type,1,&ret);
+  if(result != SWIG_OK) {
+   SWIG_Lua_pushferrstring(L,"Assignment not possible. No setter/member with this name. For custom assignments implement __setitem method.");
+   lua_error(L);
+  } else {
+    assert(ret==0);
+  }
+  return 0;
+}
+
+/* the class.destruct method called by the interpreter */
+SWIGINTERN int  SWIG_Lua_class_destruct(lua_State *L)
+{
+/*  there should be 1 params passed in
+  (1) userdata (not the meta table) */
+  swig_lua_userdata *usr;
+  swig_lua_class *clss;
+  assert(lua_isuserdata(L,-1));  /* just in case */
+  usr=(swig_lua_userdata*)lua_touserdata(L,-1);  /* get it */
+  /* if must be destroyed & has a destructor */
+  if (usr->own) /* if must be destroyed */
+  {
+    clss=(swig_lua_class*)usr->type->clientdata;  /* get the class */
+    if (clss && clss->destructor)  /* there is a destroy fn */
+    {
+      clss->destructor(usr->ptr);  /* bye bye */
+    }
+  }
+  return 0;
+}
+
+/* the class.__tostring method called by the interpreter and print */
+SWIGINTERN int  SWIG_Lua_class_tostring(lua_State *L)
+{
+/*  there should be 1 param passed in
+  (1) userdata (not the metatable) */
+  const char *className;
+  void* userData;
+  assert(lua_isuserdata(L,1));  /* just in case */
+  userData = lua_touserdata(L,1); /* get the userdata address for later */
+  lua_getmetatable(L,1);    /* get the meta table */
+  assert(lua_istable(L,-1));  /* just in case */
+
+  lua_getfield(L, -1, ".type");
+  className = lua_tostring(L, -1);
+
+  lua_pushfstring(L, "<%s userdata: %p>", className, userData);
+  return 1;
+}
+
+/* to manually disown some userdata */
+SWIGINTERN int  SWIG_Lua_class_disown(lua_State *L)
+{
+/*  there should be 1 params passed in
+  (1) userdata (not the meta table) */
+  swig_lua_userdata *usr;
+  assert(lua_isuserdata(L,-1));  /* just in case */
+  usr=(swig_lua_userdata*)lua_touserdata(L,-1);  /* get it */
+  
+  usr->own = 0; /* clear our ownership */
+  return 0;
+}
+
+/* lua callable function to compare userdata's value
+the issue is that two userdata may point to the same thing
+but to lua, they are different objects */
+SWIGRUNTIME int SWIG_Lua_class_equal(lua_State *L)
+{
+  int result;
+  swig_lua_userdata *usr1,*usr2;
+  if (!lua_isuserdata(L,1) || !lua_isuserdata(L,2))  /* just in case */
+    return 0;  /* nil reply */
+  usr1=(swig_lua_userdata*)lua_touserdata(L,1);  /* get data */
+  usr2=(swig_lua_userdata*)lua_touserdata(L,2);  /* get data */
+  /*result=(usr1->ptr==usr2->ptr && usr1->type==usr2->type); only works if type is the same*/
+  result=(usr1->ptr==usr2->ptr);
+   lua_pushboolean(L,result);
+  return 1;
+}
+
+/* populate table at the top of the stack with metamethods that ought to be inherited */
+SWIGINTERN void SWIG_Lua_populate_inheritable_metamethods(lua_State *L)
+{
+  SWIG_Lua_add_boolean(L, "__add", 1);
+  SWIG_Lua_add_boolean(L, "__sub", 1);
+  SWIG_Lua_add_boolean(L, "__mul", 1);
+  SWIG_Lua_add_boolean(L, "__div", 1);
+  SWIG_Lua_add_boolean(L, "__mod", 1);
+  SWIG_Lua_add_boolean(L, "__pow", 1);
+  SWIG_Lua_add_boolean(L, "__unm", 1);
+  SWIG_Lua_add_boolean(L, "__len", 1 );
+  SWIG_Lua_add_boolean(L, "__concat", 1 );
+  SWIG_Lua_add_boolean(L, "__eq", 1);
+  SWIG_Lua_add_boolean(L, "__lt", 1);
+  SWIG_Lua_add_boolean(L, "__le", 1);
+  SWIG_Lua_add_boolean(L, "__call", 1);
+  SWIG_Lua_add_boolean(L, "__tostring", 1);
+  SWIG_Lua_add_boolean(L, "__gc", 0);
+}
+
+/* creates the swig registry */
+SWIGINTERN void SWIG_Lua_create_class_registry(lua_State *L)
+{
+  /* create main SWIG registry table */
+  lua_pushstring(L,"SWIG");
+  lua_newtable(L);
+  /* populate it with some predefined data */
+
+  /* .library table. Placeholder */
+  lua_pushstring(L,".library");
+  lua_newtable(L);
+  {
+    /* list of metamethods that class inherits from its bases */
+    lua_pushstring(L,"inheritable_metamethods");
+    lua_newtable(L);
+    /* populate with list of metamethods */
+    SWIG_Lua_populate_inheritable_metamethods(L);
+    lua_rawset(L,-3);
+  }
+  lua_rawset(L,-3);
+
+  lua_rawset(L,LUA_REGISTRYINDEX);
+}
+
+/* gets the swig registry (or creates it) */
+SWIGINTERN void  SWIG_Lua_get_class_registry(lua_State *L)
+{
+  /* add this all into the swig registry: */
+  lua_pushstring(L,"SWIG");
+  lua_rawget(L,LUA_REGISTRYINDEX);  /* get the registry */
+  if (!lua_istable(L,-1))  /* not there */
+  {  /* must be first time, so add it */
+    lua_pop(L,1);  /* remove the result */
+    SWIG_Lua_create_class_registry(L);
+    /* then get it */
+    lua_pushstring(L,"SWIG");
+    lua_rawget(L,LUA_REGISTRYINDEX);
+  }
+}
+
+SWIGINTERN void SWIG_Lua_get_inheritable_metamethods(lua_State *L)
+{
+  SWIG_Lua_get_class_registry(L);
+  lua_pushstring(L, ".library");
+  lua_rawget(L,-2);
+  assert( !lua_isnil(L,-1) );
+  lua_pushstring(L, "inheritable_metamethods");
+  lua_rawget(L,-2);
+
+  /* Remove class registry and library table */
+  lua_remove(L,-2);
+  lua_remove(L,-2);
+}
+
+/* Helper function to get the classes metatable from the register */
+SWIGINTERN void  SWIG_Lua_get_class_metatable(lua_State *L,const char *cname)
+{
+  SWIG_Lua_get_class_registry(L);  /* get the registry */
+  lua_pushstring(L,cname);  /* get the name */
+  lua_rawget(L,-2);    /* get it */
+  lua_remove(L,-2);    /* tidy up (remove registry) */
+}
+
+/* Set up the base classes pointers.
+Each class structure has a list of pointers to the base class structures.
+This function fills them.
+It cannot be done at compile time, as this will not work with hireachies
+spread over more than one swig file. 
+Therefore it must be done at runtime, querying the SWIG type system.
+*/
+SWIGINTERN void SWIG_Lua_init_base_class(lua_State *L,swig_lua_class *clss)
+{
+  int i=0;
+  swig_module_info *module=SWIG_GetModule(L);
+  for(i=0;clss->base_names[i];i++)
+  {
+    if (clss->bases[i]==0) /* not found yet */
+    {
+      /* lookup and cache the base class */
+      swig_type_info *info = SWIG_TypeQueryModule(module,module,clss->base_names[i]);
+      if (info) clss->bases[i] = (swig_lua_class *) info->clientdata;
+    }
+  }
+}
+
+#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
+/* Merges two tables  */
+SWIGINTERN void SWIG_Lua_merge_tables_by_index(lua_State *L, int target, int source)
+{
+  /* iterating */
+  lua_pushnil(L);
+  while (lua_next(L,source) != 0) {
+    /* -1 - value, -2 - index */
+    /* have to copy to assign */
+    lua_pushvalue(L,-2); /* copy of index */
+    lua_pushvalue(L,-2); /* copy of value */
+    lua_rawset(L, target);
+    lua_pop(L,1);
+    /* only key is left */
+  }
+}
+
+/* Merges two tables with given name. original - index of target metatable, base - index of source metatable */
+SWIGINTERN void SWIG_Lua_merge_tables(lua_State *L, const char* name, int original, int base)
+{
+  /* push original[name], then base[name] */
+  lua_pushstring(L,name);
+  lua_rawget(L,original);
+  int original_table = lua_gettop(L);
+  lua_pushstring(L,name);
+  lua_rawget(L,base);
+  int base_table = lua_gettop(L);
+  SWIG_Lua_merge_tables_by_index(L, original_table, base_table);
+  /* clearing stack */
+  lua_pop(L,2);
+}
+
+/* Function takes all symbols from base and adds it to derived class. It's just a helper. */
+SWIGINTERN void SWIG_Lua_class_squash_base(lua_State *L, swig_lua_class *base_cls)
+{
+  /* There is one parameter - original, i.e. 'derived' class metatable */
+  assert(lua_istable(L,-1));
+  int original = lua_gettop(L);
+  SWIG_Lua_get_class_metatable(L,base_cls->fqname);
+  int base = lua_gettop(L);
+  SWIG_Lua_merge_tables(L, ".fn", original, base );
+  SWIG_Lua_merge_tables(L, ".set", original, base );
+  SWIG_Lua_merge_tables(L, ".get", original, base );
+  lua_pop(L,1);
+}
+
+/* Function squashes all symbols from 'clss' bases into itself */
+SWIGINTERN void  SWIG_Lua_class_squash_bases(lua_State *L, swig_lua_class *clss)
+{
+  int i;
+  SWIG_Lua_get_class_metatable(L,clss->fqname);
+  for(i=0;clss->base_names[i];i++)
+  {
+    if (clss->bases[i]==0) /* Somehow it's not found. Skip it */
+      continue;
+    /* Thing is: all bases are already registered. Thus they have already executed
+     * this function. So we just need to squash them into us, because their bases
+     * are already squashed into them. No need for recursion here!
+     */
+    SWIG_Lua_class_squash_base(L, clss->bases[i]);
+  }
+  lua_pop(L,1); /*tidy stack*/
+}
+#endif
+
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */
+/* helper add a variable to a registered class */
+SWIGINTERN void  SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn)
+{
+  assert(lua_istable(L,-1));  /* just in case */
+  SWIG_Lua_get_table(L,".get"); /* find the .get table */
+  assert(lua_istable(L,-1));  /* just in case */
+  SWIG_Lua_add_function(L,name,getFn);
+  lua_pop(L,1);       /* tidy stack (remove table) */
+  if (setFn)
+  {
+    SWIG_Lua_get_table(L,".set"); /* find the .set table */
+    assert(lua_istable(L,-1));  /* just in case */
+    SWIG_Lua_add_function(L,name,setFn);
+    lua_pop(L,1);       /* tidy stack (remove table) */
+  }
+}
+
+/* helper to recursively add class static details (static attributes, operations and constants) */
+SWIGINTERN void SWIG_Lua_add_class_static_details(lua_State *L, swig_lua_class *clss)
+{
+  int i = 0;
+  /* The class namespace table must be on the top of the stack */
+  assert(lua_istable(L,-1));
+  /* call all the base classes first: we can then override these later: */
+  for(i=0;clss->bases[i];i++)
+  {
+    SWIG_Lua_add_class_static_details(L,clss->bases[i]);
+  }
+
+  SWIG_Lua_add_namespace_details(L, clss->cls_static);
+}
+
+SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss); /* forward declaration */
+
+/* helper to recursively add class details (attributes & operations) */
+SWIGINTERN void  SWIG_Lua_add_class_instance_details(lua_State *L, swig_lua_class *clss)
+{
+  int i;
+  size_t bases_count = 0;
+  /* Add bases to .bases table */
+  SWIG_Lua_get_table(L,".bases");
+  assert(lua_istable(L,-1));  /* just in case */
+  for(i=0;clss->bases[i];i++)
+  {
+    SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname);
+    /* Base class must be already registered */
+    assert(lua_istable(L,-1));
+    lua_rawseti(L,-2,i+1); /* In lua indexing starts from 1 */
+    bases_count++;
+  }
+  assert(lua_rawlen(L,-1) == bases_count);
+  lua_pop(L,1); /* remove .bases table */
+  /* add attributes */
+  for(i=0;clss->attributes[i].name;i++){
+    SWIG_Lua_add_variable(L,clss->attributes[i].name,clss->attributes[i].getmethod,clss->attributes[i].setmethod);
+  }
+  /* add methods to the metatable */
+  SWIG_Lua_get_table(L,".fn"); /* find the .fn table */
+  assert(lua_istable(L,-1));  /* just in case */
+  for(i=0;clss->methods[i].name;i++){
+    SWIG_Lua_add_function(L,clss->methods[i].name,clss->methods[i].func);
+  }
+  lua_pop(L,1);       /* tidy stack (remove table) */
+  /* add operator overloads
+    This adds methods from metatable array to metatable. Can mess up garbage
+    collectind if someone defines __gc method
+    */
+  if(clss->metatable) {
+    for(i=0;clss->metatable[i].name;i++) {
+      SWIG_Lua_add_function(L,clss->metatable[i].name,clss->metatable[i].func);
+    }
+  }
+
+#if !defined(SWIG_LUA_SQUASH_BASES)
+  /* Adding metamethods that are defined in base classes. If bases were squashed
+   * then it is obviously unnecessary
+   */
+  SWIG_Lua_add_class_user_metamethods(L, clss);
+#endif
+}
+
+/* Helpers to add user defined class metamedhods - __add, __sub etc. The helpers are needed
+   for the following issue: Lua runtime checks for metamethod existence with rawget function
+   ignoring our SWIG-provided __index and __newindex functions. Thus our inheritance-aware method
+   search algorithm doesn't work in such case. (Not to say that Lua runtime queries metamethod directly
+   in metatable and not in object).
+   Current solution is this: if somewhere in hierarchy metamethod __x is defined, then all descendants
+   are automatically given a special proxy __x that calls the real __x method.
+   Obvious idea - to copy __x instead of creating __x-proxy is wrong because if someone changes __x in runtime,
+   those changes must be reflected in all descendants.
+*/
+
+SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L); /*forward declaration*/
+
+/* The real function that resolves a metamethod.
+ * Function searches given class and all it's bases(recursively) for first instance of something that is
+ * not equal to SWIG_Lua_resolve_metatmethod. (Almost always this 'something' is actual metamethod implementation
+ * and it is a SWIG-generated C function.). It returns value on the top of the L and there is no garbage below the
+ * answer.
+ * Returns 1 if found, 0 otherwise.
+ * clss is class which metatable we will search for method
+ * metamethod_name_idx is index in L where metamethod name (as string) lies
+ * skip_check allows to skip searching metamethod in givel clss and immideatelly go to searching in bases. skip_check
+ * is not caried to subsequent recursive calls - false is always passed. It is set to true only at first call from
+ * SWIG_Lua_resolve_metamethod
+ * */
+SWIGINTERN int SWIG_Lua_do_resolve_metamethod(lua_State *L, const swig_lua_class *clss, int metamethod_name_idx,
+    int skip_check)
+{
+  /* This function is called recursively */
+  int result = 0;
+  int i = 0;
+
+  if (!skip_check) {
+    SWIG_Lua_get_class_metatable(L, clss->fqname);
+    lua_pushvalue(L, metamethod_name_idx);
+    lua_rawget(L,-2);
+    /* If this is cfunction and it is equal to SWIG_Lua_resolve_metamethod then
+     * this isn't the function we are looking for :)
+     * lua_tocfunction will return NULL if not cfunction
+     */
+    if (!lua_isnil(L,-1) && lua_tocfunction(L,-1) != SWIG_Lua_resolve_metamethod ) {
+      lua_remove(L,-2); /* removing class metatable */
+      return 1;
+    }
+    lua_pop(L,2); /* remove class metatable and query result */
+  }
+
+  /* Forwarding calls to bases */
+  for(i=0;clss->bases[i];i++)
+  {
+    result = SWIG_Lua_do_resolve_metamethod(L, clss->bases[i], metamethod_name_idx, 0);
+    if (result)
+      break;
+  }
+
+  return result;
+}
+
+/* The proxy function for metamethod. All parameters are passed as cclosure. Searches for actual method
+ * and calls it */
+SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L)
+{
+  int numargs;
+  int metamethod_name_idx;
+  const swig_lua_class* clss;
+  int result;
+
+  lua_checkstack(L,5);
+  numargs = lua_gettop(L); /* number of arguments to pass to actual metamethod */
+  
+  /* Get upvalues from closure */
+  lua_pushvalue(L, lua_upvalueindex(1)); /*Get function name*/
+  metamethod_name_idx = lua_gettop(L);
+  
+  lua_pushvalue(L, lua_upvalueindex(2));
+  clss = (const swig_lua_class*)(lua_touserdata(L,-1));
+  lua_pop(L,1); /* remove lightuserdata with clss from stack */
+
+  /* Actual work */
+  result = SWIG_Lua_do_resolve_metamethod(L, clss, metamethod_name_idx, 1);
+  if (!result) {
+   SWIG_Lua_pushferrstring(L,"The metamethod proxy is set, but it failed to find actual metamethod. Memory corruption is most likely explanation.");
+   lua_error(L);
+   return 0;
+  }
+
+  lua_remove(L,-2); /* remove metamethod key */
+  lua_insert(L,1); /* move function to correct position */
+  lua_call(L, numargs, LUA_MULTRET);
+  return lua_gettop(L); /* return all results */
+}
+
+
+/* If given metamethod must be present in given class, then creates appropriate proxy
+ * Returns 1 if successfully added, 0 if not added because no base class has it, -1
+ * if method is defined in the class metatable itself
+ */
+SWIGINTERN int SWIG_Lua_add_class_user_metamethod(lua_State *L, swig_lua_class *clss, const int metatable_index)
+{
+  int key_index;
+  int success = 0;
+  int i = 0;
+
+  /* metamethod name - on the top of the stack */
+  assert(lua_isstring(L,-1));
+  
+  key_index = lua_gettop(L);
+
+  /* Check whether method is already defined in metatable */
+  lua_pushvalue(L,key_index); /* copy of the key */
+  lua_gettable(L,metatable_index);
+  if( !lua_isnil(L,-1) ) {
+    lua_pop(L,1);
+    return -1;
+  }
+  lua_pop(L,1); 
+
+  /* Iterating over immediate bases */
+  for(i=0;clss->bases[i];i++)
+  {
+    const swig_lua_class *base = clss->bases[i];
+    SWIG_Lua_get_class_metatable(L, base->fqname);
+    lua_pushvalue(L, key_index);
+    lua_rawget(L, -2);
+    if( !lua_isnil(L,-1) ) {
+      lua_pushvalue(L, key_index); 
+
+      /* Add proxy function */
+      lua_pushvalue(L, key_index); /* first closure value is function name */
+      lua_pushlightuserdata(L, clss); /* second closure value is swig_lua_class structure */
+      lua_pushcclosure(L, SWIG_Lua_resolve_metamethod, 2);
+      
+      lua_rawset(L, metatable_index);
+      success = 1;
+    }
+    lua_pop(L,1); /* remove function or nil */
+    lua_pop(L,1); /* remove base class metatable */
+
+    if( success )
+      break;
+  }
+
+  return success; 
+}
+
+SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss)
+{
+  int metatable_index;
+  int metamethods_info_index;
+  int tostring_undefined;
+  int eq_undefined = 0;
+
+  SWIG_Lua_get_class_metatable(L, clss->fqname);
+  metatable_index = lua_gettop(L);
+  SWIG_Lua_get_inheritable_metamethods(L);
+  assert(lua_istable(L,-1));
+  metamethods_info_index = lua_gettop(L);
+  lua_pushnil(L); /* first key */
+  while(lua_next(L, metamethods_info_index) != 0 ) {
+    /* key at index -2, value at index -1 */
+    const int is_inheritable = lua_toboolean(L,-2);
+    lua_pop(L,1); /* remove value - we don't need it anymore */
+
+    if(is_inheritable) { /* if metamethod is inheritable */
+      SWIG_Lua_add_class_user_metamethod(L,clss,metatable_index);
+    }
+  }
+
+  lua_pop(L,1); /* remove inheritable metatmethods table */
+
+  /* Special handling for __tostring method */
+  lua_pushstring(L, "__tostring");
+  lua_pushvalue(L,-1);
+  lua_rawget(L,metatable_index);
+  tostring_undefined = lua_isnil(L,-1);
+  lua_pop(L,1);
+  if( tostring_undefined ) {
+    lua_pushcfunction(L, SWIG_Lua_class_tostring);
+    lua_rawset(L, metatable_index);
+  } else {
+    lua_pop(L,1); /* remove copy of the key */
+  }
+
+  /* Special handling for __eq method */
+  lua_pushstring(L, "__eq");
+  lua_pushvalue(L,-1);
+  lua_rawget(L,metatable_index);
+  eq_undefined = lua_isnil(L,-1);
+  lua_pop(L,1);
+  if( eq_undefined ) {
+    lua_pushcfunction(L, SWIG_Lua_class_equal);
+    lua_rawset(L, metatable_index);
+  } else {
+    lua_pop(L,1); /* remove copy of the key */
+  }
+  /* Warning: __index and __newindex are SWIG-defined. For user-defined operator[]
+   * a __getitem/__setitem method should be defined
+   */
+  lua_pop(L,1); /* pop class metatable */
+}
+
+/* Register class static methods,attributes etc as well as constructor proxy */
+SWIGINTERN void SWIG_Lua_class_register_static(lua_State *L, swig_lua_class *clss)
+{
+  const int SWIGUNUSED begin = lua_gettop(L);
+  lua_checkstack(L,5); /* just in case */
+  assert(lua_istable(L,-1));  /* just in case */
+  assert(strcmp(clss->name, clss->cls_static->name) == 0); /* in class those 2 must be equal */
+
+  SWIG_Lua_namespace_register(L,clss->cls_static, 1);
+
+  assert(lua_istable(L,-1)); /* just in case */
+
+  /*  add its constructor to module with the name of the class
+  so you can do MyClass(...) as well as new_MyClass(...)
+  BUT only if a constructor is defined
+  (this overcomes the problem of pure virtual classes without constructors)*/
+  if (clss->constructor)
+  {
+    lua_getmetatable(L,-1);
+    assert(lua_istable(L,-1)); /* just in case */
+    SWIG_Lua_add_function(L,"__call", clss->constructor);
+    lua_pop(L,1);
+  }
+
+  assert(lua_istable(L,-1)); /* just in case */
+  SWIG_Lua_add_class_static_details(L, clss);
+
+  /* clear stack */
+  lua_pop(L,1);
+  assert( lua_gettop(L) == begin );
+}
+
+/* Performs the instance (non-static) class registration process. Metatable for class is created
+ * and added to the class registry.
+ */
+SWIGINTERN void  SWIG_Lua_class_register_instance(lua_State *L,swig_lua_class *clss)
+{
+  const int SWIGUNUSED begin = lua_gettop(L);
+  int i;
+  /* if name already there (class is already registered) then do nothing */
+  SWIG_Lua_get_class_registry(L);  /* get the registry */
+  lua_pushstring(L,clss->fqname);  /* get the name */
+  lua_rawget(L,-2);
+  if(!lua_isnil(L,-1)) {
+    lua_pop(L,2);
+    assert(lua_gettop(L)==begin);
+    return;
+  }
+  lua_pop(L,2); /* tidy stack */
+  /* Recursively initialize all bases */
+  for(i=0;clss->bases[i];i++)
+  {
+    SWIG_Lua_class_register_instance(L,clss->bases[i]);
+  }
+  /* Again, get registry and push name */
+  SWIG_Lua_get_class_registry(L);  /* get the registry */
+  lua_pushstring(L,clss->fqname);  /* get the name */
+  lua_newtable(L);    /* create the metatable */
+#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
+  /* If squashing is requested, then merges all bases metatable into this one.
+   * It would get us all special methods: __getitem, __add etc.
+   * This would set .fn, .type, and other .xxx incorrectly, but we will overwrite it right away
+   */
+  {
+    int new_metatable_index = lua_absindex(L,-1);
+    for(i=0;clss->bases[i];i++)
+    {
+      int base_metatable;
+      SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname);
+      base_metatable = lua_absindex(L,-1);
+      SWIG_Lua_merge_tables_by_index(L,new_metatable_index, base_metatable);
+      lua_pop(L,1);
+    }
+  }
+  /* And now we will overwrite all incorrectly set data */
+#endif
+  /* add string of class name called ".type" */
+  lua_pushstring(L,".type");
+  lua_pushstring(L,clss->fqname);
+  lua_rawset(L,-3);
+  /* add a table called bases */
+  lua_pushstring(L,".bases");
+  lua_newtable(L);
+  lua_rawset(L,-3);
+  /* add a table called ".get" */
+  lua_pushstring(L,".get");
+  lua_newtable(L);
+  lua_rawset(L,-3);
+  /* add a table called ".set" */
+  lua_pushstring(L,".set");
+  lua_newtable(L);
+  lua_rawset(L,-3);
+  /* add a table called ".fn" */
+  lua_pushstring(L,".fn");
+  lua_newtable(L);
+  /* add manual disown method */
+  SWIG_Lua_add_function(L,"__disown",SWIG_Lua_class_disown);
+  lua_rawset(L,-3);
+  /* add accessor fns for using the .get,.set&.fn */
+  SWIG_Lua_add_function(L,"__index",SWIG_Lua_class_get);
+  SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_class_set);
+  SWIG_Lua_add_function(L,"__gc",SWIG_Lua_class_destruct);
+  /* add it */
+  lua_rawset(L,-3);  /* metatable into registry */
+  lua_pop(L,1);      /* tidy stack (remove registry) */
+  assert(lua_gettop(L) == begin);
+
+#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
+  /* Now merge all symbols from .fn, .set, .get etc from bases to our tables */
+  SWIG_Lua_class_squash_bases(L,clss);
+#endif
+  SWIG_Lua_get_class_metatable(L,clss->fqname);
+  SWIG_Lua_add_class_instance_details(L,clss);  /* recursive adding of details (atts & ops) */
+  lua_pop(L,1);      /* tidy stack (remove class metatable) */
+  assert( lua_gettop(L) == begin );
+}
+
+SWIGINTERN void  SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss)
+{
+  int SWIGUNUSED begin;
+  assert(lua_istable(L,-1)); /* This is a table (module or namespace) where classes will be added */
+  SWIG_Lua_class_register_instance(L,clss);
+  SWIG_Lua_class_register_static(L,clss);
+
+  /* Add links from static part to instance part and vice versa */
+  /* [SWIG registry]                                   [Module]
+   *    "MyClass" ----> [MyClass metatable] <=====     "MyClass" -+> [static part]
+   *                     ".get" ----> ...        |                |     getmetatable()----|
+   *                     ".set" ----> ...        |                |                       |
+   *                     ".static" --------------)----------------/           [static part metatable]
+   *                                             |                                ".get" --> ...
+   *                                             |                                ".set" --> ....
+   *                                             |=============================== ".instance"
+   */
+  begin = lua_gettop(L);
+  lua_pushstring(L,clss->cls_static->name);
+  lua_rawget(L,-2); /* get class static table */
+  assert(lua_istable(L,-1));
+  lua_getmetatable(L,-1);
+  assert(lua_istable(L,-1)); /* get class static metatable */
+  lua_pushstring(L,".instance"); /* prepare key */
+
+  SWIG_Lua_get_class_metatable(L,clss->fqname); /* get class metatable */
+  assert(lua_istable(L,-1));
+  lua_pushstring(L,".static"); /* prepare key */
+  lua_pushvalue(L, -4); /* push static class TABLE */
+  assert(lua_istable(L,-1));
+  lua_rawset(L,-3); /* assign static class table(!NOT metatable) as ".static" member of class metatable */
+  lua_rawset(L,-3); /* assign class metatable as ".instance" member of class static METATABLE */
+  lua_pop(L,2);
+  assert(lua_gettop(L) == begin);
+}
+#endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */
+
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
+SWIGINTERN void SWIG_Lua_elua_class_register_instance(lua_State *L, swig_lua_class *clss)
+{
+  const int SWIGUNUSED begin = lua_gettop(L);
+  int i;
+  /* if name already there (class is already registered) then do nothing */
+  SWIG_Lua_get_class_registry(L);  /* get the registry */
+  lua_pushstring(L,clss->fqname);  /* get the name */
+  lua_rawget(L,-2);
+  if(!lua_isnil(L,-1)) {
+    lua_pop(L,2);
+    assert(lua_gettop(L)==begin);
+    return;
+  }
+  lua_pop(L,2); /* tidy stack */
+  /* Recursively initialize all bases */
+  for(i=0;clss->bases[i];i++)
+  {
+    SWIG_Lua_elua_class_register_instance(L,clss->bases[i]);
+  }
+  /* Again, get registry and push name */
+  SWIG_Lua_get_class_registry(L);  /* get the registry */
+  lua_pushstring(L,clss->fqname);  /* get the name */
+  assert(clss->metatable);
+  lua_pushrotable(L, (void*)(clss->metatable));    /* create the metatable */
+  lua_rawset(L,-3);
+  lua_pop(L,1);
+  assert(lua_gettop(L) == begin);
+}
+#endif /* elua && eluac */
+
+/* -----------------------------------------------------------------------------
+ * Class/structure conversion fns
+ * ----------------------------------------------------------------------------- */
+
+/* helper to add metatable to new lua object */
+SWIGINTERN void SWIG_Lua_AddMetatable(lua_State *L,swig_type_info *type)
+{
+  if (type->clientdata)  /* there is clientdata: so add the metatable */
+  {
+    SWIG_Lua_get_class_metatable(L,((swig_lua_class*)(type->clientdata))->fqname);
+    if (lua_istable(L,-1))
+    {
+      lua_setmetatable(L,-2);
+    }
+    else
+    {
+      lua_pop(L,1);
+    }
+  }
+}
+
+/* pushes a new object into the lua stack */
+SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own)
+{
+  swig_lua_userdata *usr;
+  if (!ptr){
+    lua_pushnil(L);
+    return;
+  }
+  usr=(swig_lua_userdata*)lua_newuserdata(L,sizeof(swig_lua_userdata));  /* get data */
+  usr->ptr=ptr;  /* set the ptr */
+  usr->type=type;
+  usr->own=own;
+#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
+  SWIG_Lua_AddMetatable(L,type); /* add metatable */
+#endif
+}
+
+/* takes a object from the lua stack & converts it into an object of the correct type
+ (if possible) */
+SWIGRUNTIME int  SWIG_Lua_ConvertPtr(lua_State *L,int index,void **ptr,swig_type_info *type,int flags)
+{
+  swig_lua_userdata *usr;
+  swig_cast_info *cast;
+  if (lua_isnil(L,index)){*ptr=0; return SWIG_OK;}    /* special case: lua nil => NULL pointer */
+  usr=(swig_lua_userdata*)lua_touserdata(L,index);  /* get data */
+  if (usr)
+  {
+    if (flags & SWIG_POINTER_DISOWN) /* must disown the object */
+    {
+        usr->own=0;
+    }
+    if (!type)            /* special cast void*, no casting fn */
+    {
+      *ptr=usr->ptr;
+      return SWIG_OK; /* ok */
+    }
+    cast=SWIG_TypeCheckStruct(usr->type,type); /* performs normal type checking */
+    if (cast)
+    {
+      int newmemory = 0;
+      *ptr=SWIG_TypeCast(cast,usr->ptr,&newmemory);
+      assert(!newmemory); /* newmemory handling not yet implemented */
+      return SWIG_OK;  /* ok */
+    }
+  }
+  return SWIG_ERROR;  /* error */
+}
+
+SWIGRUNTIME void* SWIG_Lua_MustGetPtr(lua_State *L,int index,swig_type_info *type,int flags,
+       int argnum,const char *func_name){
+  void *result;
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,index,&result,type,flags))){
+    luaL_error (L,"Error in %s, expected a %s at argument number %d\n",
+		func_name,(type && type->str)?type->str:"void*",argnum);
+  }
+  return result;
+}
+
+/* pushes a packed userdata. user for member fn pointers only */
+SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type)
+{
+  swig_lua_rawdata *raw;
+  assert(ptr); /* not acceptable to pass in a NULL value */
+  raw=(swig_lua_rawdata*)lua_newuserdata(L,sizeof(swig_lua_rawdata)-1+size);  /* alloc data */
+  raw->type=type;
+  raw->own=0;
+  memcpy(raw->data,ptr,size); /* copy the data */
+  SWIG_Lua_AddMetatable(L,type); /* add metatable */
+}
+    
+/* converts a packed userdata. user for member fn pointers only */
+SWIGRUNTIME int  SWIG_Lua_ConvertPacked(lua_State *L,int index,void *ptr,size_t size,swig_type_info *type)
+{
+  swig_lua_rawdata *raw;
+  raw=(swig_lua_rawdata*)lua_touserdata(L,index);  /* get data */
+  if (!raw) return SWIG_ERROR;  /* error */
+  if (type==0 || type==raw->type) /* void* or identical type */
+  {
+    memcpy(ptr,raw->data,size); /* copy it */
+    return SWIG_OK; /* ok */
+  }
+  return SWIG_ERROR;  /* error */
+}
+
+/* a function to get the typestring of a piece of data */
+SWIGRUNTIME const char *SWIG_Lua_typename(lua_State *L, int tp)
+{
+  swig_lua_userdata *usr;
+  if (lua_isuserdata(L,tp))
+  {
+    usr=(swig_lua_userdata*)lua_touserdata(L,tp);  /* get data */
+    if (usr && usr->type && usr->type->str)
+      return usr->type->str;
+    return "userdata (unknown type)";
+  }
+  return lua_typename(L,lua_type(L,tp));
+}
+
+/* lua callable function to get the userdata's type */
+SWIGRUNTIME int SWIG_Lua_type(lua_State *L)
+{
+  lua_pushstring(L,SWIG_Lua_typename(L,1));
+  return 1;
+}
+
+/* -----------------------------------------------------------------------------
+ * global variable support code: class/struct typemap functions
+ * ----------------------------------------------------------------------------- */
+
+#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC))
+/* Install Constants */
+SWIGINTERN void
+SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]) {
+  int i;
+  for (i = 0; constants[i].type; i++) {
+    switch(constants[i].type) {
+    case SWIG_LUA_INT:
+      lua_pushstring(L,constants[i].name);
+      lua_pushinteger(L,(lua_Number)constants[i].lvalue);
+      lua_rawset(L,-3);
+      break;
+    case SWIG_LUA_FLOAT:
+      lua_pushstring(L,constants[i].name);
+      lua_pushnumber(L,(lua_Number)constants[i].dvalue);
+      lua_rawset(L,-3);
+      break;
+    case SWIG_LUA_CHAR:
+      lua_pushstring(L,constants[i].name);
+      {
+        char c = constants[i].lvalue;
+        lua_pushlstring(L,&c,1);
+      }
+      lua_rawset(L,-3);
+      break;
+    case SWIG_LUA_STRING:
+      lua_pushstring(L,constants[i].name);
+      lua_pushstring(L,(char *) constants[i].pvalue);
+      lua_rawset(L,-3);
+      break;
+    case SWIG_LUA_POINTER:
+      lua_pushstring(L,constants[i].name);
+      SWIG_NewPointerObj(L,constants[i].pvalue, *(constants[i]).ptype,0);
+      lua_rawset(L,-3);
+      break;
+    case SWIG_LUA_BINARY:
+      lua_pushstring(L,constants[i].name);
+      SWIG_NewMemberObj(L,constants[i].pvalue,constants[i].lvalue,*(constants[i]).ptype);
+      lua_rawset(L,-3);
+      break;
+    default:
+      break;
+    }
+  }
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * executing lua code from within the wrapper
+ * ----------------------------------------------------------------------------- */
+
+#ifndef SWIG_DOSTRING_FAIL /* Allows redefining of error function */
+#define SWIG_DOSTRING_FAIL(S) fprintf(stderr,"%s\n",S)
+#endif
+/* Executes a C string in Lua which is a really simple way of calling lua from C
+Unfortunately lua keeps changing its APIs, so we need a conditional compile
+In lua 5.0.X it's lua_dostring()
+In lua 5.1.X it's luaL_dostring()
+*/
+SWIGINTERN int 
+SWIG_Lua_dostring(lua_State *L, const char *str) {
+  int ok,top;
+  if (str==0 || str[0]==0) return 0; /* nothing to do */
+  top=lua_gettop(L); /* save stack */
+#if (defined(LUA_VERSION_NUM) && (LUA_VERSION_NUM>=501))
+  ok=luaL_dostring(L,str);	/* looks like this is lua 5.1.X or later, good */
+#else
+  ok=lua_dostring(L,str);	/* might be lua 5.0.x, using lua_dostring */
+#endif
+  if (ok!=0) {
+    SWIG_DOSTRING_FAIL(lua_tostring(L,-1));
+  }
+  lua_settop(L,top); /* restore the stack */
+  return ok;
+}    
+
+#ifdef __cplusplus
+}
+#endif
+
+/* ------------------------------ end luarun.swg  ------------------------------ */
diff --git a/share/swig/3.0.12/lua/luaruntime.swg b/share/swig/3.0.12/lua/luaruntime.swg
new file mode 100644
index 0000000..8df46e8
--- /dev/null
+++ b/share/swig/3.0.12/lua/luaruntime.swg
@@ -0,0 +1,103 @@
+/* -----------------------------------------------------------------------------
+ * luaruntime.swg
+ *
+ * all the runtime code for .
+ * ----------------------------------------------------------------------------- */
+
+%runtime "swigrun.swg";         /* Common C API type-checking code */
+%runtime "luarun.swg";          /* Lua runtime stuff */
+
+%insert(initbeforefunc) "swiginit.swg"
+
+%insert(initbeforefunc) %{
+
+/* Forward declaration of where the user's %init{} gets inserted */
+void SWIG_init_user(lua_State* L );
+    
+#ifdef __cplusplus
+extern "C" {
+#endif
+/* this is the initialization function
+  added at the very end of the code
+  the function is always called SWIG_init, but an earlier #define will rename it
+*/
+#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
+LUALIB_API int SWIG_init(lua_State* L)
+#else
+SWIGEXPORT int SWIG_init(lua_State* L) /* default Lua action */
+#endif
+{
+#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) /* valid for both Lua and eLua */
+  int i;
+  int globalRegister = 0;
+  /* start with global table */
+  lua_pushglobaltable (L);
+  /* SWIG's internal initialisation */
+  SWIG_InitializeModule((void*)L);
+  SWIG_PropagateClientData();
+#endif
+
+#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)) || defined(SWIG_LUA_ELUA_EMULATE)
+  /* add a global fn */
+  SWIG_Lua_add_function(L,"swig_type",SWIG_Lua_type);
+  SWIG_Lua_add_function(L,"swig_equals",SWIG_Lua_class_equal);
+#endif
+
+#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
+  /* set up base class pointers (the hierarchy) */
+  for (i = 0; swig_types[i]; i++){
+    if (swig_types[i]->clientdata){
+      SWIG_Lua_init_base_class(L,(swig_lua_class*)(swig_types[i]->clientdata));
+    }
+  }
+#ifdef SWIG_LUA_MODULE_GLOBAL
+  globalRegister = 1;
+#endif
+
+
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
+  SWIG_Lua_namespace_register(L,&swig_SwigModule, globalRegister);
+#endif
+
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
+  for (i = 0; swig_types[i]; i++){
+    if (swig_types[i]->clientdata){
+      SWIG_Lua_elua_class_register_instance(L,(swig_lua_class*)(swig_types[i]->clientdata));
+    }
+  }
+#endif
+
+#if defined(SWIG_LUA_ELUA_EMULATE)
+  lua_newtable(L);
+  SWIG_Lua_elua_emulate_register(L,swig_SwigModule.ns_methods);
+  SWIG_Lua_elua_emulate_register_clear(L);
+  if(globalRegister) {
+    lua_pushstring(L,swig_SwigModule.name);
+    lua_pushvalue(L,-2);
+    lua_rawset(L,-4);
+  }
+#endif
+
+#endif
+
+#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
+  /* invoke user-specific initialization */
+  SWIG_init_user(L);
+  /* end module */
+  /* Note: We do not clean up the stack here (Lua will do this for us). At this
+     point, we have the globals table and out module table on the stack. Returning
+     one value makes the module table the result of the require command. */
+  return 1;
+#else
+  return 0;
+#endif
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+%}
+
+/* Note: the initialization function is closed after all code is generated */
+
diff --git a/share/swig/3.0.12/lua/luatypemaps.swg b/share/swig/3.0.12/lua/luatypemaps.swg
new file mode 100644
index 0000000..5d98e61
--- /dev/null
+++ b/share/swig/3.0.12/lua/luatypemaps.swg
@@ -0,0 +1,412 @@
+/* -----------------------------------------------------------------------------
+ * luatypemaps.swg
+ *
+ * basic typemaps for Lua.
+ * ----------------------------------------------------------------------------- */
+
+/* -----------------------------------------------------------------------------
+ *                          standard typemaps
+ * ----------------------------------------------------------------------------- */
+/* NEW LANGUAGE NOTE:
+   the 'checkfn' param is something that I added for typemap(in)
+   it is an optional fn call to check the type of the lua object
+   the fn call must be of the form
+     int checkfn(lua_State *L, int index);
+   and return 1/0 depending upon if this is the correct type
+   For the typemap(out), an additional SWIG_arg parameter must be incremented
+   to reflect the number of values returned (normally SWIG_arg++; will do)
+*/
+// numbers
+%typemap(in,checkfn="lua_isnumber") int, short, long,
+             signed char, float, double
+%{$1 = ($type)lua_tonumber(L, $input);%}
+ 
+// additional check for unsigned numbers, to not permit negative input
+%typemap(in,checkfn="lua_isnumber") unsigned int,
+             unsigned short, unsigned long, unsigned char
+%{SWIG_contract_assert((lua_tonumber(L,$input)>=0),"number must not be negative")
+$1 = ($type)lua_tonumber(L, $input);%}
+
+%typemap(out) int,short,long,
+             unsigned int,unsigned short,unsigned long,
+             signed char,unsigned char,
+             float,double
+%{  lua_pushnumber(L, (lua_Number) $1); SWIG_arg++;%}
+
+// we must also provide typemaps for primitives by const reference:
+// given a function:
+//	int intbyref(const int& i);
+// SWIG assumes that this code will need a pointer to int to be passed in
+// (this might be ok for objects by const ref, but not for numeric primitives)
+// therefore we add a set of typemaps to fix this (for both in & out)
+%typemap(in,checkfn="lua_isnumber") const int&($basetype temp)
+%{ temp=($basetype)lua_tonumber(L,$input); $1=&temp;%}
+
+%typemap(in,checkfn="lua_isnumber") const unsigned int&($basetype temp)
+%{SWIG_contract_assert((lua_tonumber(L,$input)>=0),"number must not be negative")
+temp=($basetype)lua_tonumber(L,$input); $1=&temp;%}
+
+%typemap(out) const int&, const unsigned int&
+%{  lua_pushnumber(L, (lua_Number) *$1); SWIG_arg++;%}
+
+// for the other numbers we can just use an apply statement to cover them
+%apply const int & {const short&,const long&,const signed char&,
+             const float&,const double&};
+
+%apply const unsigned int & {const unsigned short&,const unsigned long&,
+             const unsigned char&};
+
+/* enums have to be handled slightly differently
+	VC++ .net will not allow a cast from lua_Number(double) to enum directly.
+*/
+%typemap(in,checkfn="lua_isnumber") enum SWIGTYPE
+%{$1 = ($type)(int)lua_tonumber(L, $input);%}
+
+%typemap(out) enum SWIGTYPE
+%{  lua_pushnumber(L, (lua_Number)(int)($1)); SWIG_arg++;%}
+
+// and const refs
+%typemap(in,checkfn="lua_isnumber") const enum SWIGTYPE &($basetype temp)
+%{ temp=($basetype)(int)lua_tonumber(L,$input); $1=&temp;%}
+%typemap(in,checkfn="lua_isnumber") const enum SWIGTYPE &&($basetype temp)
+%{ temp=($basetype)(int)lua_tonumber(L,$input); $1=&temp;%}
+%typemap(out) const enum SWIGTYPE &
+%{  lua_pushnumber(L, (lua_Number) *$1); SWIG_arg++;%}
+%typemap(out) const enum SWIGTYPE &&
+%{  lua_pushnumber(L, (lua_Number) *$1); SWIG_arg++;%}
+
+
+// boolean (which is a special type in lua)
+// note: lua_toboolean() returns 1 or 0
+// note: 1 & 0 are not booleans in lua, only true & false
+%typemap(in,checkfn="lua_isboolean") bool
+%{$1 = (lua_toboolean(L, $input)!=0);%}
+
+%typemap(out) bool
+%{  lua_pushboolean(L,(int)($1!=0)); SWIG_arg++;%}
+
+// for const bool&, SWIG treats this as a const bool* so we must dereference it
+%typemap(in,checkfn="lua_isboolean") const bool& (bool temp)
+%{temp=(lua_toboolean(L, $input)!=0);
+  $1=&temp;%}
+
+%typemap(out) const bool&
+%{  lua_pushboolean(L,(int)((*$1)!=0)); SWIG_arg++;%}
+
+// strings (char * and char[])
+%fragment("SWIG_lua_isnilstring", "header") {
+SWIGINTERN int SWIG_lua_isnilstring(lua_State *L, int idx) {
+  int ret = lua_isstring(L, idx);
+  if (!ret)
+   ret = lua_isnil(L, idx);
+  return ret;
+}
+}
+
+%typemap(in,checkfn="SWIG_lua_isnilstring",fragment="SWIG_lua_isnilstring") const char *, char *
+%{$1 = ($ltype)lua_tostring(L, $input);%}
+
+%typemap(in,checkfn="SWIG_lua_isnilstring",fragment="SWIG_lua_isnilstring") const char[ANY], char[ANY]
+%{$1 = ($ltype)lua_tostring(L, $input);%}
+
+%typemap(out) const char *, char *
+%{  lua_pushstring(L,(const char *)$1); SWIG_arg++;%}
+
+%typemap(out) const char[ANY], char[ANY]
+%{  lua_pushstring(L,(const char *)$1); SWIG_arg++;%}
+
+// char's
+// currently treating chars as small strings, not as numbers
+// (however signed & unsigned char's are numbers...)
+%typemap(in,checkfn="SWIG_lua_isnilstring",fragment="SWIG_lua_isnilstring") char
+%{$1 = (lua_tostring(L, $input))[0];%}
+
+%typemap(out) char
+%{  lua_pushlstring(L, &$1, 1); SWIG_arg++;%}
+
+// by const ref
+%typemap(in,checkfn="SWIG_lua_isnilstring",fragment="SWIG_lua_isnilstring") const char& (char temp)
+%{temp = (lua_tostring(L, $input))[0]; $1=&temp;%}
+
+%typemap(out) const char&
+%{  lua_pushlstring(L, $1, 1); SWIG_arg++;%}
+
+// pointers and references
+// under SWIG rules, it is ok, to have a pass in a lua nil,
+// it should be converted to a SWIG NULL.
+// This will only be allowed for pointers & arrays, not refs or by value
+// the checkfn lua_isuserdata will only work for userdata
+// the checkfn SWIG_isptrtype will work for both userdata and nil
+%typemap(in,checkfn="SWIG_isptrtype") SWIGTYPE*,SWIGTYPE[]
+%{
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,$input,(void**)&$1,$descriptor,$disown))){
+    SWIG_fail_ptr("$symname",$argnum,$descriptor);
+  }
+%}
+
+%typemap(in,checkfn="lua_isuserdata") SWIGTYPE&
+%{
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,$input,(void**)&$1,$descriptor,$disown))){
+    SWIG_fail_ptr("$symname",$argnum,$descriptor);
+  }
+%}
+
+%typemap(in,checkfn="lua_isuserdata") SWIGTYPE&&
+%{
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,$input,(void**)&$1,$descriptor,$disown))){
+    SWIG_fail_ptr("$symname",$argnum,$descriptor);
+  }
+%}
+
+// out is simple
+%typemap(out) SWIGTYPE*,SWIGTYPE&
+%{SWIG_NewPointerObj(L,$1,$descriptor,$owner); SWIG_arg++; %}
+%typemap(out) SWIGTYPE*,SWIGTYPE&&
+%{SWIG_NewPointerObj(L,$1,$descriptor,$owner); SWIG_arg++; %}
+
+// dynamic casts
+// this uses the SWIG_TypeDynamicCast() which relies on RTTI to find out what the pointer really is
+// the we return it as the correct type
+%typemap(out) SWIGTYPE *DYNAMIC,
+              SWIGTYPE &DYNAMIC
+{
+  swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor, (void **) &$1);
+  SWIG_NewPointerObj(L,(void*)$1,ty,$owner); SWIG_arg++; 
+}
+
+
+// passing objects by value
+// SWIG_ConvertPtr wants an object pointer (the $&ltype argp)
+// then dereferences it to get the object
+%typemap(in,checkfn="lua_isuserdata") SWIGTYPE ($&ltype argp)
+%{
+   if (!SWIG_IsOK(SWIG_ConvertPtr(L,$input,(void**)&argp,$&descriptor,0))){
+     SWIG_fail_ptr("$symname",$argnum,$&descriptor);
+   }
+   $1 = *argp;
+%}
+
+// Also needed for object ptrs by const ref
+// eg A* const& ref_pointer(A* const& a);
+// found in mixed_types.i
+%typemap(in,checkfn="lua_isuserdata") SWIGTYPE *const&($*ltype temp)
+%{temp=($*ltype)SWIG_MustGetPtr(L,$input,$*descriptor,0,$argnum,"$symname");
+$1=($1_ltype)&temp;%}
+
+%typemap(out) SWIGTYPE *const&
+%{SWIG_NewPointerObj(L,*$1,$*descriptor,$owner); SWIG_arg++; %}
+
+
+// DISOWN-ing typemaps
+// if you have an object pointer which must be disowned, use this typemap
+// eg. for void destroy_foo(Foo* toDie);
+// use %apply SWIGTYPE* DISOWN {Foo* toDie};
+// you could just use %delobject, but this is more flexible
+%typemap(in,checkfn="SWIG_isptrtype") SWIGTYPE* DISOWN,SWIGTYPE DISOWN[]
+%{  if (!SWIG_IsOK(SWIG_ConvertPtr(L,$input,(void**)&$1,$descriptor,SWIG_POINTER_DISOWN))){
+    SWIG_fail_ptr("$symname",$argnum,$descriptor);
+  }
+%}
+
+
+// Primitive types--return by value
+// must make a new object, copy the data & return the new object
+// Note: the brackets are {...} and not %{..%}, because we want them to be included in the wrapper
+// this is because typemap(out) does not support local variables, like in typemap(in) does
+// and we need the $&1_ltype resultptr; to be declared
+#ifdef __cplusplus
+%typemap(out) SWIGTYPE
+{
+  $&1_ltype resultptr = new $1_ltype((const $1_ltype &) $1);
+  SWIG_NewPointerObj(L,(void *) resultptr,$&1_descriptor,1); SWIG_arg++;
+}
+#else
+%typemap(out) SWIGTYPE
+{
+  $&1_ltype resultptr;
+  resultptr = ($&1_ltype) malloc(sizeof($1_type));
+  memmove(resultptr, &$1, sizeof($1_type));
+  SWIG_NewPointerObj(L,(void *) resultptr,$&1_descriptor,1); SWIG_arg++;
+}
+#endif
+
+// member function pointer
+// a member fn ptr is not 4 bytes like a normal pointer, but 8 bytes (at least on mingw)
+// so the standard wrapping cannot be done
+// nor can you cast a member function pointer to a void* (obviously)
+// therefore a special wrapping functions SWIG_ConvertMember() & SWIG_NewMemberObj() were written
+#ifdef __cplusplus
+%typemap(in,checkfn="lua_isuserdata") SWIGTYPE (CLASS::*)
+%{
+  if (!SWIG_IsOK(SWIG_ConvertMember(L,$input,(void*)(&$1),sizeof($type),$descriptor)))
+    SWIG_fail_ptr("$symname",$argnum,$descriptor);
+%}
+
+%typemap(out) SWIGTYPE (CLASS::*)
+%{ 
+  SWIG_NewMemberObj(L,(void*)(&$1),sizeof($type),$descriptor); SWIG_arg++; 
+%}
+#endif
+
+
+// void (must be empty without the SWIG_arg++)
+%typemap(out) void "";
+
+/* void* is a special case
+A function void fn(void*) should take any kind of pointer as a parameter (just like C/C++ does)
+but if its an output, then it should be wrapped like any other SWIG object (using default typemap)
+*/
+%typemap(in,checkfn="SWIG_isptrtype") void*
+%{$1=($1_ltype)SWIG_MustGetPtr(L,$input,0,0,$argnum,"$symname");%}
+
+/* long long is another special case:
+as lua only supports one numeric type (lua_Number), we will just
+cast it to that & accept the loss of precision.
+An alternative solution would be a long long struct or class
+with the relevant operators.
+*/
+%apply long {long long, signed long long, unsigned long long};
+%apply const long& {const long long&, const signed long long&, const unsigned long long&};
+
+/* It is possible to also pass a lua_State* into a function, so
+void fn(int a, float b, lua_State* s) is wrappable as
+> fn(1,4.3) -- note: the state is implicitly passed in
+*/
+%typemap(in, numinputs=0) lua_State* 
+%{$1 = L;%}
+
+
+
+/* -----------------------------------------------------------------------------
+ *                          typecheck rules
+ * ----------------------------------------------------------------------------- */
+/* These are needed for the overloaded functions
+These define the detection routines which will spot what
+parameters match which function
+*/
+
+// unfortunately lua only considers one type of number
+// so all numbers (int,float,double) match
+// you could add an advanced fn to get type & check if its integral
+%typecheck(SWIG_TYPECHECK_INTEGER)
+	 int, short, long,
+ 	 unsigned int, unsigned short, unsigned long,
+	 signed char, unsigned char,
+	 long long, unsigned long long, signed long long,
+	 const int &, const short &, const long &,
+ 	 const unsigned int &, const unsigned short &, const unsigned long &,
+	 const signed char&, const unsigned char&,
+	 const long long &, const unsigned long long &,
+	 enum SWIGTYPE,	const enum SWIGTYPE&, const enum SWIGTYPE &&,
+	 float, double, const float &, const double&
+{
+  $1 = lua_isnumber(L,$input);
+}
+
+%typecheck(SWIG_TYPECHECK_BOOL)
+    bool, const bool &
+{
+  $1 = lua_isboolean(L,$input);
+}
+
+// special check for a char (string of length 1)
+%typecheck(SWIG_TYPECHECK_CHAR,fragment="SWIG_lua_isnilstring") char, const char& {
+  $1 = SWIG_lua_isnilstring(L,$input) && (lua_rawlen(L,$input)==1);
+}
+
+%typecheck(SWIG_TYPECHECK_STRING,fragment="SWIG_lua_isnilstring") char *, char[] {
+  $1 = SWIG_lua_isnilstring(L,$input);
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE [] {
+  void *ptr;
+  if (SWIG_isptrtype(L,$input)==0 || SWIG_ConvertPtr(L,$input, (void **) &ptr, $1_descriptor, 0)) {
+    $1 = 0;
+  } else {
+    $1 = 1;
+  }
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE & {
+  void *ptr;
+  if (lua_isuserdata(L,$input)==0 || SWIG_ConvertPtr(L,$input, (void **) &ptr, $1_descriptor, 0)) {
+    $1 = 0;
+  } else {
+    $1 = 1;
+  }
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE && {
+  void *ptr;
+  if (lua_isuserdata(L,$input)==0 || SWIG_ConvertPtr(L,$input, (void **) &ptr, $1_descriptor, 0)) {
+    $1 = 0;
+  } else {
+    $1 = 1;
+  }
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE {
+  void *ptr;
+  if (lua_isuserdata(L,$input)==0 || SWIG_ConvertPtr(L,$input, (void **) &ptr, $&1_descriptor, 0)) {
+    $1 = 0;
+  } else {
+    $1 = 1;
+  }
+}
+
+%typecheck(SWIG_TYPECHECK_VOIDPTR) void * {
+  void *ptr;
+  if (SWIG_isptrtype(L,$input)==0 || SWIG_ConvertPtr(L,$input, (void **) &ptr, 0, 0)) {
+    $1 = 0;
+  } else {
+    $1 = 1;
+  }
+}
+
+// Also needed for object pointers by const ref
+// eg const A* ref_pointer(A* const& a);
+// found in mixed_types.i
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *const&
+{
+  void *ptr;
+  if (lua_isuserdata(L,$input)==0 || SWIG_ConvertPtr(L,$input, (void **) &ptr, $*descriptor, 0)) {
+    $1 = 0;
+  } else {
+    $1 = 1;
+  }
+}
+
+/* -----------------------------------------------------------------------------
+ *                          Others
+ * ----------------------------------------------------------------------------- */
+
+// Array reference typemaps
+%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) }
+
+/* const pointers */
+%apply SWIGTYPE * { SWIGTYPE *const }
+
+// size_t (which is just a unsigned long)
+%apply unsigned long { size_t };
+%apply const unsigned long & { const size_t & };
+
+
+/* -----------------------------------------------------------------------------
+ *                          Specials
+ * ----------------------------------------------------------------------------- */
+// swig::LANGUAGE_OBJ was added to allow containers of native objects
+// however its rather difficult to do this in lua, as you cannot hold pointers
+// to native objects (they are held in the interpreter)
+// therefore for now: just ignoring this feature
+#ifdef __cplusplus
+%ignore swig::LANGUAGE_OBJ;
+
+//%inline %{
+%{
+namespace swig {
+typedef struct{} LANGUAGE_OBJ;
+}
+%}
+
+#endif // __cplusplus
diff --git a/share/swig/3.0.12/lua/std_common.i b/share/swig/3.0.12/lua/std_common.i
new file mode 100644
index 0000000..cee11e8
--- /dev/null
+++ b/share/swig/3.0.12/lua/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/perl5/std_deque.i b/share/swig/3.0.12/lua/std_deque.i
index cb98f6c..cb98f6c 100644
--- a/share/swig/2.0.11/perl5/std_deque.i
+++ b/share/swig/3.0.12/lua/std_deque.i
diff --git a/share/swig/3.0.12/lua/std_except.i b/share/swig/3.0.12/lua/std_except.i
new file mode 100644
index 0000000..34ab6a1
--- /dev/null
+++ b/share/swig/3.0.12/lua/std_except.i
@@ -0,0 +1,42 @@
+/* -----------------------------------------------------------------------------
+ * 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);
+ *
+ * std_except.i
+ * ----------------------------------------------------------------------------- */
+
+%{
+#include <typeinfo>
+#include <stdexcept>
+%}
+%include <exception.i>
+
+namespace std 
+{
+  %ignore exception; // not sure if I should ignore this...
+  class exception 
+  {
+  public:
+    exception() throw() { }
+    virtual ~exception() throw();
+    virtual const char* what() const throw();
+  }; 
+}
+
+// normally objects which are thrown are returned to the interpreter as errors
+// (which potentially may have problems if they are not copied)
+// therefore all classes based upon std::exception are converted to their strings & returned as errors
+%typemap(throws) std::bad_cast          "SWIG_exception(SWIG_TypeError, $1.what());"
+%typemap(throws) std::bad_exception     "SWIG_exception(SWIG_RuntimeError, $1.what());"
+%typemap(throws) std::domain_error      "SWIG_exception(SWIG_ValueError, $1.what());"
+%typemap(throws) std::exception         "SWIG_exception(SWIG_SystemError, $1.what());"
+%typemap(throws) std::invalid_argument  "SWIG_exception(SWIG_ValueError, $1.what());"
+%typemap(throws) std::length_error      "SWIG_exception(SWIG_IndexError, $1.what());"
+%typemap(throws) std::logic_error       "SWIG_exception(SWIG_RuntimeError, $1.what());"
+%typemap(throws) std::out_of_range      "SWIG_exception(SWIG_IndexError, $1.what());"
+%typemap(throws) std::overflow_error    "SWIG_exception(SWIG_OverflowError, $1.what());"
+%typemap(throws) std::range_error       "SWIG_exception(SWIG_IndexError, $1.what());"
+%typemap(throws) std::runtime_error     "SWIG_exception(SWIG_RuntimeError, $1.what());"
+%typemap(throws) std::underflow_error   "SWIG_exception(SWIG_RuntimeError, $1.what());"
diff --git a/share/swig/2.0.11/lua/std_map.i b/share/swig/3.0.12/lua/std_map.i
index 84b0c74..84b0c74 100644
--- a/share/swig/2.0.11/lua/std_map.i
+++ b/share/swig/3.0.12/lua/std_map.i
diff --git a/share/swig/2.0.11/lua/std_pair.i b/share/swig/3.0.12/lua/std_pair.i
index 0672853..0672853 100644
--- a/share/swig/2.0.11/lua/std_pair.i
+++ b/share/swig/3.0.12/lua/std_pair.i
diff --git a/share/swig/2.0.11/lua/std_string.i b/share/swig/3.0.12/lua/std_string.i
index e9f326b..e9f326b 100644
--- a/share/swig/2.0.11/lua/std_string.i
+++ b/share/swig/3.0.12/lua/std_string.i
diff --git a/share/swig/2.0.11/lua/std_vector.i b/share/swig/3.0.12/lua/std_vector.i
index a4ea978..a4ea978 100644
--- a/share/swig/2.0.11/lua/std_vector.i
+++ b/share/swig/3.0.12/lua/std_vector.i
diff --git a/share/swig/3.0.12/lua/stl.i b/share/swig/3.0.12/lua/stl.i
new file mode 100644
index 0000000..04f8601
--- /dev/null
+++ b/share/swig/3.0.12/lua/stl.i
@@ -0,0 +1,10 @@
+/* -----------------------------------------------------------------------------
+ * 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/3.0.12/lua/typemaps.i b/share/swig/3.0.12/lua/typemaps.i
new file mode 100644
index 0000000..c662cd3
--- /dev/null
+++ b/share/swig/3.0.12/lua/typemaps.i
@@ -0,0 +1,564 @@
+/* -----------------------------------------------------------------------------
+ * typemaps.swg
+ *
+ * SWIG Library file containing the main typemap code to support Lua modules.
+ * ----------------------------------------------------------------------------- */
+
+/* -----------------------------------------------------------------------------
+ *                          Basic inout typemaps
+ * ----------------------------------------------------------------------------- */
+/*
+These provide the basic ability for passing in & out of standard numeric data types
+(int,long,float,double, etc)
+
+The basic code looks like this:
+
+%typemap(in,checkfn="lua_isnumber") int *INPUT(int temp), int &INPUT(int temp)
+%{ temp = (int)lua_tonumber(L,$input);
+   $1 = &temp; %}
+
+%typemap(in, numinputs=0) int *OUTPUT (int temp)
+%{ $1 = &temp; %}
+
+%typemap(argout) int *OUTPUT
+%{  lua_pushnumber(L, (double) *$1); SWIG_arg++;%}
+
+%typemap(in) int *INOUT = int *INPUT;
+%typemap(argout) int *INOUT = int *OUTPUT;
+
+However the code below is a mixture of #defines & such, so nowhere as easy to read
+
+To make you code work correctly its not just a matter of %including this file
+You also have to give SWIG the hints on which to use where
+
+eg
+extern int add_pointer(int* a1,int* a2); // a1 & a2 are pointer values to be added
+extern void swap(int* s1, int* s2);	// does the swap
+
+You will need to either change the argument names
+extern int add_pointer(int* INPUT,int* INPUT);
+
+or provide a %apply statement
+
+%apply int* INOUT{ int *s1, int *s2 };
+	// if SWIG sees int* s1, int* s2, assume they are inout params
+*/
+
+
+%define SWIG_NUMBER_TYPEMAP(TYPE)
+%typemap(in,checkfn="lua_isnumber")	TYPE *INPUT($*ltype temp), TYPE &INPUT($*ltype temp)
+%{ temp = ($*ltype)lua_tonumber(L,$input);
+   $1 = &temp; %}
+%typemap(in, numinputs=0) TYPE *OUTPUT ($*ltype temp)
+%{ $1 = &temp; %}
+%typemap(argout) TYPE *OUTPUT
+%{  lua_pushnumber(L, (lua_Number) *$1); SWIG_arg++;%}
+%typemap(in) TYPE *INOUT = TYPE *INPUT;
+%typemap(argout) TYPE *INOUT = TYPE *OUTPUT;
+%typemap(in) TYPE &OUTPUT = TYPE *OUTPUT;
+%typemap(argout) TYPE &OUTPUT = TYPE *OUTPUT;
+%typemap(in) TYPE &INOUT = TYPE *INPUT;
+%typemap(argout) TYPE &INOUT = TYPE *OUTPUT;
+// const version (the $*ltype is the basic number without ptr or const's)
+%typemap(in,checkfn="lua_isnumber")	const TYPE *INPUT($*ltype temp)
+%{ temp = ($*ltype)lua_tonumber(L,$input);
+   $1 = &temp; %}
+%enddef
+
+// now the code
+SWIG_NUMBER_TYPEMAP(unsigned char); SWIG_NUMBER_TYPEMAP(signed char);
+
+SWIG_NUMBER_TYPEMAP(short); SWIG_NUMBER_TYPEMAP(unsigned short); SWIG_NUMBER_TYPEMAP(signed short);
+SWIG_NUMBER_TYPEMAP(int); SWIG_NUMBER_TYPEMAP(unsigned int); SWIG_NUMBER_TYPEMAP(signed int);
+SWIG_NUMBER_TYPEMAP(long); SWIG_NUMBER_TYPEMAP(unsigned long); SWIG_NUMBER_TYPEMAP(signed long);
+SWIG_NUMBER_TYPEMAP(float);
+SWIG_NUMBER_TYPEMAP(double);
+SWIG_NUMBER_TYPEMAP(enum SWIGTYPE);
+// also for long longs's
+SWIG_NUMBER_TYPEMAP(long long); SWIG_NUMBER_TYPEMAP(unsigned long long); SWIG_NUMBER_TYPEMAP(signed long long);
+
+// note we dont do char, as a char* is probably a string not a ptr to a single char
+
+// similar for booleans
+%typemap(in,checkfn="lua_isboolean") bool *INPUT(bool temp), bool &INPUT(bool temp)
+%{ temp = (lua_toboolean(L,$input)!=0);
+   $1 = &temp; %}
+
+%typemap(in, numinputs=0) bool *OUTPUT (bool temp),bool &OUTPUT (bool temp)
+%{ $1 = &temp; %}
+
+%typemap(argout) bool *OUTPUT,bool &OUTPUT
+%{  lua_pushboolean(L, (int)((*$1)!=0)); SWIG_arg++;%}
+
+%typemap(in) bool *INOUT = bool *INPUT;
+%typemap(argout) bool *INOUT = bool *OUTPUT;
+%typemap(in) bool &INOUT = bool &INPUT;
+%typemap(argout) bool &INOUT = bool &OUTPUT;
+
+/* -----------------------------------------------------------------------------
+ *                          Basic Array typemaps
+ * ----------------------------------------------------------------------------- */
+/*
+I have no idea why this kind of code does not exist in SWIG as standard,
+but here is it.
+This code will convert to/from 1D numeric arrays.
+In order to reduce code bloat, there are a few macros
+and quite a few functions defined
+(unfortunately this makes it a lot less clear)
+
+assuming we have functions
+void process_array(int arr[3]);	// nice fixed size array
+void process_var_array(float arr[],int len);	// variable sized array
+void process_var_array_inout(double* arr,int len);	// variable sized array
+			// data passed in & out
+void process_enum_inout_array_var(enum Days *arrinout, int len);	// using enums
+void return_array_5(int arrout[5]);	// out array only
+
+in order to wrap them correctly requires a typemap
+
+// inform SWIG of the correct typemap
+// For fixed length, you must specify it as <type> INPUT[ANY]
+%apply (int INPUT[ANY]) {(int arr[3])};
+// variable length arrays are just the same
+%apply (float INPUT[],int) {(float arr[],int len)};
+// it is also ok, to map the TYPE* instead of a TYPE[]
+%apply (double *INOUT,int) {(double arr*,int len)};
+// for the enum's you must use enum SWIGTYPE
+%apply (enum SWIGTYPE *INOUT,int) {(enum Days *arrinout, int len)};
+// fixed length out if also fine
+%apply (int OUTPUT[ANY]) {(int arrout[5])};
+
+Generally, you could use %typemap(...)=...
+but the %apply is neater & easier
+
+a few things of note:
+* all Lua tables are indexed from 1, all C/C++ arrays are indexed from 0
+	therefore t={6,5,3} -- t[1]==6, t[2]==5, t[3]==3
+	when passed to process_array(int arr[3]) becomes
+	arr[0]==6, arr[1]==5, arr[2]==3
+* for OUTPUT arrays, no array need be passed in, the fn will return a Lua table
+	so for the above mentioned return_array_5() would look like
+	arr=return_array_5() -- no parameters passed in
+* for INOUT arrays, a table must be passed in, and a new table will be returned
+	(this is consistent with the way that numbers are processed)
+	if you want just use
+	arr={...}
+	arr=process_var_array_inout(arr)	-- arr is replaced by the new version
+
+The following are not yet supported:
+* variable length output only array (inout works ok)
+* multidimensional arrays
+* arrays of objects/structs
+* arrays of pointers
+
+*/
+
+/*
+The internals of the array management stuff
+helper fns/macros
+SWIG_ALLOC_ARRAY(TYPE,LEN)	// returns a typed array TYPE[LEN]
+SWIG_FREE_ARRAY(PTR)		// delete the ptr (if not zero)
+
+// counts the specified table & gets the size
+// integer version
+int SWIG_itable_size(lua_State* L, int index);
+// other version
+int SWIG_table_size(lua_State* L, int index);
+
+SWIG_DECLARE_TYPEMAP_ARR_FN(NAME,TYPE)
+// this fn declares up 4 functions for helping to read/write tables
+// these can then be called by the macros ...
+// all assume the table is an integer indexes from 1
+// but the C array is a indexed from 0
+	// created a fixed size array, reads the specified table
+	// and then fills the array with numbers
+	// returns ptr to the array if ok, or 0 for error
+	// (also pushes a error message to the stack)
+TYPE* SWIG_get_NAME_num_array_fixed(lua_State* L, int index, int size);
+	// as per SWIG_get_NAME_num_array_fixed()
+	// but reads the entire table & creates an array of the correct size
+	// (if the table is empty, it returns an error rather than a zero length array)
+TYPE* SWIG_get_NAME_num_array_var(lua_State* L, int index, int* size);
+	// writes a table to Lua with all the specified numbers
+void SWIG_write_NAME_num_array(lua_State* L,TYPE *array,int size);
+	// read the specified table, and fills the array with numbers
+	// returns 1 of ok (only fails if it doesnt find numbers)
+	// helper fn (called by SWIG_get_NAME_num_array_*() fns)
+int SWIG_read_NAME_num_array(lua_State* L,int index,TYPE *array,int size);
+
+*/
+
+/* Reported that you don't need to check for NULL for delete & free
+There probably is some compiler that its not true for, so the code is left here just in case.
+#ifdef __cplusplus	
+#define SWIG_ALLOC_ARRAY(TYPE,LEN) 	new TYPE[LEN]
+#define SWIG_FREE_ARRAY(PTR)		if(PTR){delete[] PTR;}
+#else
+#define SWIG_ALLOC_ARRAY(TYPE,LEN) 	(TYPE *)malloc(LEN*sizeof(TYPE))
+#define SWIG_FREE_ARRAY(PTR)		if(PTR){free(PTR);}
+#endif
+*/
+%{
+#ifdef __cplusplus	/* generic alloc/dealloc fns*/
+#define SWIG_ALLOC_ARRAY(TYPE,LEN) 	new TYPE[LEN]
+#define SWIG_FREE_ARRAY(PTR)		delete[] PTR
+#else
+#define SWIG_ALLOC_ARRAY(TYPE,LEN) 	(TYPE *)malloc(LEN*sizeof(TYPE))
+#define SWIG_FREE_ARRAY(PTR)		free(PTR)
+#endif
+/* counting the size of arrays:*/
+SWIGINTERN int SWIG_itable_size(lua_State* L, int index)
+{
+	int n=0;
+	while(1){
+		lua_rawgeti(L,index,n+1);
+		if (lua_isnil(L,-1))break;
+		++n;
+		lua_pop(L,1);
+	}
+	lua_pop(L,1);
+	return n;
+}
+
+SWIGINTERN int SWIG_table_size(lua_State* L, int index)
+{
+	int n=0;
+	lua_pushnil(L);  /* first key*/
+	while (lua_next(L, index) != 0) {
+		++n;
+		lua_pop(L, 1);  /* removes `value'; keeps `key' for next iteration*/
+	}
+	return n;
+}
+
+/* super macro to declare array typemap helper fns */
+#define SWIG_DECLARE_TYPEMAP_ARR_FN(NAME,TYPE)\
+	SWIGINTERN int SWIG_read_##NAME##_num_array(lua_State* L,int index,TYPE *array,int size){\
+		int i;\
+		for (i = 0; i < size; i++) {\
+			lua_rawgeti(L,index,i+1);\
+			if (lua_isnumber(L,-1)){\
+				array[i] = (TYPE)lua_tonumber(L,-1);\
+			} else {\
+				lua_pop(L,1);\
+				return 0;\
+			}\
+			lua_pop(L,1);\
+		}\
+		return 1;\
+	}\
+	SWIGINTERN TYPE* SWIG_get_##NAME##_num_array_fixed(lua_State* L, int index, int size){\
+		TYPE *array;\
+		if (!lua_istable(L,index) || SWIG_itable_size(L,index) != size) {\
+			SWIG_Lua_pushferrstring(L,"expected a table of size %d",size);\
+			return 0;\
+		}\
+		array=SWIG_ALLOC_ARRAY(TYPE,size);\
+		if (!SWIG_read_##NAME##_num_array(L,index,array,size)){\
+			SWIG_Lua_pusherrstring(L,"table must contain numbers");\
+			SWIG_FREE_ARRAY(array);\
+			return 0;\
+		}\
+		return array;\
+	}\
+	SWIGINTERN TYPE* SWIG_get_##NAME##_num_array_var(lua_State* L, int index, int* size)\
+	{\
+		TYPE *array;\
+		if (!lua_istable(L,index)) {\
+			SWIG_Lua_pusherrstring(L,"expected a table");\
+			return 0;\
+		}\
+		*size=SWIG_itable_size(L,index);\
+		if (*size<1){\
+			SWIG_Lua_pusherrstring(L,"table appears to be empty");\
+			return 0;\
+		}\
+		array=SWIG_ALLOC_ARRAY(TYPE,*size);\
+		if (!SWIG_read_##NAME##_num_array(L,index,array,*size)){\
+			SWIG_Lua_pusherrstring(L,"table must contain numbers");\
+			SWIG_FREE_ARRAY(array);\
+			return 0;\
+		}\
+		return array;\
+	}\
+	SWIGINTERN void SWIG_write_##NAME##_num_array(lua_State* L,TYPE *array,int size){\
+		int i;\
+		lua_newtable(L);\
+		for (i = 0; i < size; i++){\
+			lua_pushnumber(L,(lua_Number)array[i]);\
+			lua_rawseti(L,-2,i+1);/* -1 is the number, -2 is the table*/ \
+		}\
+	}
+%}
+
+/*
+This is one giant macro to define the typemaps & the helpers
+for array handling
+*/
+%define SWIG_TYPEMAP_NUM_ARR(NAME,TYPE)
+%{SWIG_DECLARE_TYPEMAP_ARR_FN(NAME,TYPE)%}
+
+// fixed size array's
+%typemap(in) TYPE INPUT[ANY]
+%{	$1 = SWIG_get_##NAME##_num_array_fixed(L,$input,$1_dim0);
+	if (!$1) SWIG_fail;%}
+
+%typemap(freearg) TYPE INPUT[ANY]
+%{	SWIG_FREE_ARRAY($1);%}
+
+// variable size array's
+%typemap(in) (TYPE *INPUT,int)
+%{	$1 = SWIG_get_##NAME##_num_array_var(L,$input,&$2);
+	if (!$1) SWIG_fail;%}
+
+%typemap(freearg) (TYPE *INPUT,int)
+%{	SWIG_FREE_ARRAY($1);%}
+
+// out fixed arrays
+%typemap(in,numinputs=0) TYPE OUTPUT[ANY]
+%{  $1 = SWIG_ALLOC_ARRAY(TYPE,$1_dim0); %}
+
+%typemap(argout) TYPE OUTPUT[ANY]
+%{	SWIG_write_##NAME##_num_array(L,$1,$1_dim0); SWIG_arg++; %}
+
+%typemap(freearg) TYPE OUTPUT[ANY]
+%{	SWIG_FREE_ARRAY($1); %}
+
+// inout fixed arrays
+%typemap(in) TYPE INOUT[ANY]=TYPE INPUT[ANY];
+%typemap(argout) TYPE INOUT[ANY]=TYPE OUTPUT[ANY];
+%typemap(freearg) TYPE INOUT[ANY]=TYPE INPUT[ANY];
+// inout variable arrays
+%typemap(in) (TYPE *INOUT,int)=(TYPE *INPUT,int);
+%typemap(argout) (TYPE *INOUT,int)
+%{	SWIG_write_##NAME##_num_array(L,$1,$2); SWIG_arg++; %}
+%typemap(freearg) (TYPE *INOUT,int)=(TYPE *INPUT,int);
+
+// TODO out variable arrays (is there a standard form for such things?)
+
+// referencing so that (int *INPUT,int) and (int INPUT[],int) are the same
+%typemap(in) (TYPE INPUT[],int)=(TYPE *INPUT,int);
+%typemap(freearg) (TYPE INPUT[],int)=(TYPE *INPUT,int);
+
+%enddef
+
+// the following line of code
+// declares the C helper fns for the array typemaps
+// as well as defining typemaps for
+// fixed len arrays in & out, & variable length arrays in
+
+SWIG_TYPEMAP_NUM_ARR(schar,signed char);
+SWIG_TYPEMAP_NUM_ARR(uchar,unsigned char);
+SWIG_TYPEMAP_NUM_ARR(int,int);
+SWIG_TYPEMAP_NUM_ARR(uint,unsigned int);
+SWIG_TYPEMAP_NUM_ARR(short,short);
+SWIG_TYPEMAP_NUM_ARR(ushort,unsigned short);
+SWIG_TYPEMAP_NUM_ARR(long,long);
+SWIG_TYPEMAP_NUM_ARR(ulong,unsigned long);
+SWIG_TYPEMAP_NUM_ARR(float,float);
+SWIG_TYPEMAP_NUM_ARR(double,double);
+
+// again enums are a problem so they need their own type
+// we use the int conversion routine & recast it
+%typemap(in) enum SWIGTYPE INPUT[ANY]
+%{	$1 = ($ltype)SWIG_get_int_num_array_fixed(L,$input,$1_dim0);
+	if (!$1) SWIG_fail;%}
+
+%typemap(freearg) enum SWIGTYPE INPUT[ANY]
+%{	SWIG_FREE_ARRAY($1);%}
+
+// variable size arrays
+%typemap(in) (enum SWIGTYPE *INPUT,int)
+%{	$1 = ($ltype)SWIG_get_int_num_array_var(L,$input,&$2);
+	if (!$1) SWIG_fail;%}
+
+%typemap(freearg) (enum SWIGTYPE *INPUT,int)
+%{	SWIG_FREE_ARRAY($1);%}
+
+// out fixed arrays
+%typemap(in,numinputs=0) enum SWIGTYPE OUTPUT[ANY]
+%{  $1 = SWIG_ALLOC_ARRAY(enum SWIGTYPE,$1_dim0); %}
+
+%typemap(argout) enum SWIGTYPE OUTPUT[ANY]
+%{	SWIG_write_int_num_array(L,(int*)$1,$1_dim0); SWIG_arg++; %}
+
+%typemap(freearg) enum SWIGTYPE OUTPUT[ANY]
+%{	SWIG_FREE_ARRAY($1); %}
+
+// inout fixed arrays
+%typemap(in) enum SWIGTYPE INOUT[ANY]=enum SWIGTYPE INPUT[ANY];
+%typemap(argout) enum SWIGTYPE INOUT[ANY]=enum SWIGTYPE OUTPUT[ANY];
+%typemap(freearg) enum SWIGTYPE INOUT[ANY]=enum SWIGTYPE INPUT[ANY];
+// inout variable arrays
+%typemap(in) (enum SWIGTYPE *INOUT,int)=(enum SWIGTYPE *INPUT,int);
+%typemap(argout) (enum SWIGTYPE *INOUT,int)
+%{	SWIG_write_int_num_array(L,(int*)$1,$2); SWIG_arg++; %}
+%typemap(freearg) (enum SWIGTYPE *INOUT,int)=(enum SWIGTYPE *INPUT,int);
+
+
+/* Surprisingly pointer arrays are easier:
+this is because all ptr arrays become void**
+so only a few fns are needed & a few casts
+
+The function defined are
+	// created a fixed size array, reads the specified table
+	// and then fills the array with pointers (checking the type)
+	// returns ptr to the array if ok, or 0 for error
+	// (also pushes a error message to the stack)
+void** SWIG_get_ptr_array_fixed(lua_State* L, int index, int size,swig_type_info *type);
+	// as per SWIG_get_ptr_array_fixed()
+	// but reads the entire table & creates an array of the correct size
+	// (if the table is empty, it returns an error rather than a zero length array)
+void** SWIG_get_ptr_array_var(lua_State* L, int index, int* size,swig_type_info *type);
+	// writes a table to Lua with all the specified pointers
+	// all pointers have the ownership value 'own' (normally 0)
+void SWIG_write_ptr_array(lua_State* L,void **array,int size,int own);
+	// read the specified table, and fills the array with ptrs
+	// returns 1 of ok (only fails if it doesn't find correct type of ptrs)
+	// helper fn (called by SWIG_get_ptr_array_*() fns)
+int SWIG_read_ptr_array(lua_State* L,int index,void **array,int size,swig_type_info *type);
+
+The key thing to remember is that it is assumed that there is no
+modification of pointers ownership in the arrays
+
+eg A fn:
+void pointers_in(TYPE* arr[],int len);
+will make copies of the pointer into a temp array and then pass it into the fn
+Lua does not remember that this fn held the pointers, so it is not safe to keep
+these pointers until later
+
+eg A fn:
+void pointers_out(TYPE* arr[3]);
+will return a table containing three pointers
+however these pointers are NOT owned by Lua, merely borrowed
+so if the C/C++ frees then Lua is not aware
+
+*/
+
+%{
+SWIGINTERN int SWIG_read_ptr_array(lua_State* L,int index,void **array,int size,swig_type_info *type){
+	int i;
+	for (i = 0; i < size; i++) {
+		lua_rawgeti(L,index,i+1);
+		if (!lua_isuserdata(L,-1) || SWIG_ConvertPtr(L,-1,&array[i],type,0)==-1){
+			lua_pop(L,1);
+			return 0;
+		}
+		lua_pop(L,1);
+	}
+	return 1;
+}
+SWIGINTERN void** SWIG_get_ptr_array_fixed(lua_State* L, int index, int size,swig_type_info *type){
+	void **array;
+	if (!lua_istable(L,index) || SWIG_itable_size(L,index) != size) {
+		SWIG_Lua_pushferrstring(L,"expected a table of size %d",size);
+		return 0;
+	}
+	array=SWIG_ALLOC_ARRAY(void*,size);
+	if (!SWIG_read_ptr_array(L,index,array,size,type)){
+		SWIG_Lua_pushferrstring(L,"table must contain pointers of type %s",type->name);
+		SWIG_FREE_ARRAY(array);
+		return 0;
+	}
+	return array;
+}
+SWIGINTERN void** SWIG_get_ptr_array_var(lua_State* L, int index, int* size,swig_type_info *type){
+	void **array;
+	if (!lua_istable(L,index)) {
+		SWIG_Lua_pusherrstring(L,"expected a table");
+		return 0;
+	}
+	*size=SWIG_itable_size(L,index);
+	if (*size<1){
+		SWIG_Lua_pusherrstring(L,"table appears to be empty");
+		return 0;
+	}
+	array=SWIG_ALLOC_ARRAY(void*,*size);
+	if (!SWIG_read_ptr_array(L,index,array,*size,type)){
+		SWIG_Lua_pushferrstring(L,"table must contain pointers of type %s",type->name);
+		SWIG_FREE_ARRAY(array);
+		return 0;
+	}
+	return array;
+}
+SWIGINTERN void SWIG_write_ptr_array(lua_State* L,void **array,int size,swig_type_info *type,int own){
+	int i;
+	lua_newtable(L);
+	for (i = 0; i < size; i++){
+		SWIG_NewPointerObj(L,array[i],type,own);
+		lua_rawseti(L,-2,i+1);/* -1 is the number, -2 is the table*/
+	}
+}
+%}
+
+// fixed size array's
+%typemap(in) SWIGTYPE* INPUT[ANY]
+%{	$1 = ($ltype)SWIG_get_ptr_array_fixed(L,$input,$1_dim0,$*1_descriptor);
+	if (!$1) SWIG_fail;%}
+
+%typemap(freearg) SWIGTYPE* INPUT[ANY]
+%{	SWIG_FREE_ARRAY($1);%}
+
+// variable size array's
+%typemap(in) (SWIGTYPE **INPUT,int)
+%{	$1 = ($ltype)SWIG_get_ptr_array_var(L,$input,&$2,$*1_descriptor);
+	if (!$1) SWIG_fail;%}
+
+%typemap(freearg) (SWIGTYPE **INPUT,int)
+%{	SWIG_FREE_ARRAY($1);%}
+
+// out fixed arrays
+%typemap(in,numinputs=0) SWIGTYPE* OUTPUT[ANY]
+%{  $1 = SWIG_ALLOC_ARRAY($*1_type,$1_dim0); %}
+
+%typemap(argout) SWIGTYPE* OUTPUT[ANY]
+%{	SWIG_write_ptr_array(L,(void**)$1,$1_dim0,$*1_descriptor,0); SWIG_arg++; %}
+
+%typemap(freearg) SWIGTYPE* OUTPUT[ANY]
+%{	SWIG_FREE_ARRAY($1); %}
+
+// inout fixed arrays
+%typemap(in) SWIGTYPE* INOUT[ANY]=SWIGTYPE* INPUT[ANY];
+%typemap(argout) SWIGTYPE* INOUT[ANY]=SWIGTYPE* OUTPUT[ANY];
+%typemap(freearg) SWIGTYPE* INOUT[ANY]=SWIGTYPE* INPUT[ANY];
+// inout variable arrays
+%typemap(in) (SWIGTYPE** INOUT,int)=(SWIGTYPE** INPUT,int);
+%typemap(argout) (SWIGTYPE** INOUT,int)
+%{	SWIG_write_ptr_array(L,(void**)$1,$2,$*1_descriptor,0); SWIG_arg++; %}
+%typemap(freearg) (SWIGTYPE**INOUT,int)=(SWIGTYPE**INPUT,int);
+
+/* -----------------------------------------------------------------------------
+ *                          Pointer-Pointer typemaps
+ * ----------------------------------------------------------------------------- */
+/*
+This code is to deal with the issue for pointer-pointer's
+In particular for factory methods.
+
+for example take the following code segment:
+
+struct iMath;    // some structure
+int Create_Math(iMath** pptr); // its factory (assume it mallocs)
+
+to use it you might have the following C code:
+
+iMath* ptr;
+int ok;
+ok=Create_Math(&ptr);
+// do things with ptr
+//...
+free(ptr);
+
+With the following SWIG code
+%apply SWIGTYPE** OUTPUT{iMath **pptr };
+
+You can get natural wrapping in Lua as follows:
+ok,ptr=Create_Math() -- ptr is a iMath* which is returned with the int
+ptr=nil -- the iMath* will be GC'ed as normal
+*/
+
+%typemap(in,numinputs=0) SWIGTYPE** OUTPUT ($*ltype temp)
+%{ temp = ($*ltype)0;
+   $1 = &temp; %}
+%typemap(argout) SWIGTYPE** OUTPUT
+%{SWIG_NewPointerObj(L,*$1,$*descriptor,1); SWIG_arg++; %}
+
diff --git a/share/swig/3.0.12/lua/wchar.i b/share/swig/3.0.12/lua/wchar.i
new file mode 100644
index 0000000..9f3be6f
--- /dev/null
+++ b/share/swig/3.0.12/lua/wchar.i
@@ -0,0 +1,42 @@
+/* -----------------------------------------------------------------------------
+ * wchar.i
+ *
+ * Typemaps for the wchar_t type
+ * These are mapped to a Lua string and are passed around by value.
+ * ----------------------------------------------------------------------------- */
+
+// note: only support for pointer right now, not fixed length strings
+// TODO: determine how long a const wchar_t* is so we can write wstr2str() 
+// & do the output typemap
+
+%{
+#include <stdlib.h>
+	
+wchar_t* str2wstr(const char *str, int len)
+{
+  wchar_t* p;
+  if (str==0 || len<1)  return 0;
+  p=(wchar_t *)malloc((len+1)*sizeof(wchar_t));
+  if (p==0)	return 0;
+  if (mbstowcs(p, str, len)==(size_t)-1)
+  {
+    free(p);
+    return 0;
+  }
+  p[len]=0;
+  return p;
+}
+%}
+
+%typemap(in, checkfn="SWIG_lua_isnilstring", fragment="SWIG_lua_isnilstring") wchar_t *
+%{
+$1 = str2wstr(lua_tostring( L, $input ),lua_rawlen( L, $input ));
+if ($1==0) {SWIG_Lua_pushferrstring(L,"Error in converting to wchar (arg %d)",$input);goto fail;}
+%}
+
+%typemap(freearg) wchar_t *
+%{
+free($1);
+%}
+
+%typemap(typecheck) wchar_t * = char *;
diff --git a/share/swig/2.0.11/math.i b/share/swig/3.0.12/math.i
index a37c92d..a37c92d 100644
--- a/share/swig/2.0.11/math.i
+++ b/share/swig/3.0.12/math.i
diff --git a/share/swig/3.0.12/modula3/modula3.swg b/share/swig/3.0.12/modula3/modula3.swg
new file mode 100644
index 0000000..262f8ea
--- /dev/null
+++ b/share/swig/3.0.12/modula3/modula3.swg
@@ -0,0 +1,785 @@
+/* -----------------------------------------------------------------------------
+ * modula3.swg
+ *
+ * Modula3 typemaps
+ * ----------------------------------------------------------------------------- */
+
+%include <modula3head.swg>
+
+/* The ctype, m3rawtype and m3wraptype typemaps work together and so there should be one of each. 
+ * The ctype typemap contains the C type used in the signature of C wrappers for C++ functions. 
+ * The m3rawtype typemap contains the M3 type used in the raw interface.
+ * The m3rawintype typemap contains the M3 type used as function argument.
+ * The m3rawrettype typemap contains the M3 type used as return value.
+ * The m3wraptype typemap contains the M3 type used in the M3 type wrapper classes and module class. */
+
+/* Primitive types */
+%typemap(ctype) bool,               const bool &               "bool"
+%typemap(ctype) char,               const char &               "char"
+%typemap(ctype) signed char,        const signed char &        "signed char"
+%typemap(ctype) unsigned char,      const unsigned char &      "unsigned short"
+%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) char *                                         "char *"
+%typemap(ctype) void                                           "void"
+
+%typemap(m3rawtype) bool,               const bool &               "BOOLEAN"
+%typemap(m3rawtype) char,               const char &               "C.char"
+%typemap(m3rawtype) signed char,        const signed char &        "C.signed_char"
+%typemap(m3rawtype) unsigned char,      const unsigned char &      "C.unsigned_char"
+%typemap(m3rawtype) short,              const short &              "C.short"
+%typemap(m3rawtype) unsigned short,     const unsigned short &     "C.unsigned_short"
+%typemap(m3rawtype) int,                const int &                "C.int"
+%typemap(m3rawtype) unsigned int,       const unsigned int &       "C.unsigned_int"
+%typemap(m3rawtype) long,               const long &               "C.long"
+%typemap(m3rawtype) unsigned long,      const unsigned long &      "C.unsigned_long"
+%typemap(m3rawtype) long long,          const long long &          "C.long_long"
+%typemap(m3rawtype) unsigned long long, const unsigned long long & "C.unsigned_long_long"
+%typemap(m3rawtype) float,              const float &              "C.float"
+%typemap(m3rawtype) double,             const double &             "C.double"
+%typemap(m3rawtype) long double,        const long double &        "C.long_double"
+%typemap(m3rawtype) char *                                         "C.char_star"
+%typemap(m3rawtype) void                                           ""
+%typemap(m3rawtype) FILE                                           "Cstdio.FILE";
+%typemap(m3rawtype) FILE *                                         "Cstdio.FILE_star";
+
+
+%typemap(m3rawintype) bool *,               bool &,               bool               "BOOLEAN"
+%typemap(m3rawintype) char *,               char &,               char               "C.char"
+%typemap(m3rawintype) signed char *,        signed char &,        signed char        "C.signed_char"
+%typemap(m3rawintype) unsigned char *,      unsigned char &,      unsigned char      "C.unsigned_char"
+%typemap(m3rawintype) short *,              short &,              short              "C.short"
+%typemap(m3rawintype) unsigned short *,     unsigned short &,     unsigned short     "C.unsigned_short"
+%typemap(m3rawintype) int *,                int &,                int                "C.int"
+%typemap(m3rawintype) unsigned int *,       unsigned int &,       unsigned int       "C.unsigned_int"
+%typemap(m3rawintype) long *,               long &,               long               "C.long"
+%typemap(m3rawintype) unsigned long *,      unsigned long &,      unsigned long      "C.unsigned_long"
+%typemap(m3rawintype) long long *,          long long &,          long long          "C.long_long"
+%typemap(m3rawintype) unsigned long long *, unsigned long long &, unsigned long long "C.unsigned_long_long"
+%typemap(m3rawintype) float *,              float &,              float              "C.float"
+%typemap(m3rawintype) double *,             double &,             double             "C.double"
+%typemap(m3rawintype) long double *,        long double &,        long double        "C.long_double"
+%typemap(m3rawintype) char *                                                         "C.char_star"
+%typemap(m3rawintype) void                                                           ""
+%typemap(m3rawintype) void *                                                         "ADDRESS"
+%typemap(m3rawintype) FILE                                                           "Cstdio.FILE";
+%typemap(m3rawintype) FILE *                                                         "Cstdio.FILE_star";
+
+%typemap(m3rawinmode) char *, void *, FILE *  ""
+
+
+%typemap(m3rawrettype) bool,               const bool &               "BOOLEAN"
+%typemap(m3rawrettype) char,               const char &               "C.char"
+%typemap(m3rawrettype) signed char,        const signed char &        "C.signed_char"
+%typemap(m3rawrettype) unsigned char,      const unsigned char &      "C.unsigned_char"
+%typemap(m3rawrettype) short,              const short &              "C.short"
+%typemap(m3rawrettype) unsigned short,     const unsigned short &     "C.unsigned_short"
+%typemap(m3rawrettype) int,                const int &                "C.int"
+%typemap(m3rawrettype) unsigned int,       const unsigned int &       "C.unsigned_int"
+%typemap(m3rawrettype) long,               const long &               "C.long"
+%typemap(m3rawrettype) unsigned long,      const unsigned long &      "C.unsigned_long"
+%typemap(m3rawrettype) long long,          const long long &          "C.long_long"
+%typemap(m3rawrettype) unsigned long long, const unsigned long long & "C.unsigned_long_long"
+%typemap(m3rawrettype) float,              const float &              "C.float"
+%typemap(m3rawrettype) double,             const double &             "C.double"
+%typemap(m3rawrettype) long double,        const long double &        "C.long_double"
+%typemap(m3rawrettype) char *                                         "C.char_star"
+%typemap(m3rawrettype) void                                           ""
+%typemap(m3rawrettype) void *                                         "ADDRESS"
+%typemap(m3rawrettype) FILE                                           "Cstdio.FILE";
+%typemap(m3rawrettype) FILE *                                         "Cstdio.FILE_star";
+
+
+%typemap("m3rawtype:import")
+  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 &,
+  long double,        const long double &,
+  char *
+    "Ctypes AS C"
+
+%typemap("m3rawintype:import")
+  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 &,
+  long double,        const long double &,
+  char *
+    "Ctypes AS C"
+
+%typemap("m3rawrettype:import")
+  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 &,
+  long double,        const long double &,
+  char *
+    "Ctypes AS C"
+
+%typemap("m3rawtype:import")
+  FILE,   FILE *
+    "Cstdio";
+
+%typemap("m3rawintype:import")
+  FILE,   FILE *
+    "Cstdio";
+
+%typemap("m3rawrettype:import")
+  FILE,   FILE *
+    "Cstdio";
+
+%typemap(m3wraptype) bool,               const bool &               "BOOLEAN"
+%typemap(m3wraptype) char,               const char &               "CHAR"
+%typemap(m3wraptype) signed char,        const signed char &        "CHAR"
+%typemap(m3wraptype) unsigned char,      const unsigned char &      "CHAR"
+%typemap(m3wraptype) short,              const short &              "Integer16.T"
+%typemap(m3wraptype) unsigned short,     const unsigned short &     "Cardinal16.T"
+%typemap(m3wraptype) int,                const int &                "INTEGER"
+%typemap(m3wraptype) unsigned int,       const unsigned int &       "CARDINAL"
+%typemap(m3wraptype) long,               const long &               "Integer32.T"
+%typemap(m3wraptype) unsigned long,      const unsigned long &      "Cardinal32.T"
+%typemap(m3wraptype) long long,          const long long &          "Integer64.T"
+%typemap(m3wraptype) unsigned long long, const unsigned long long & "Cardinal64.T"
+%typemap(m3wraptype) float,              const float &              "REAL"
+%typemap(m3wraptype) double,             const double &             "LONGREAL"
+%typemap(m3wraptype) long double,        const long double &        "EXTENDED"
+%typemap(m3wraptype) char *                                         "TEXT"
+%typemap(m3wraptype) void                                           ""
+%typemap(m3wraptype) FILE                                           "Cstdio.FILE";
+%typemap(m3wraptype) FILE *                                         "Cstdio.FILE_star";
+
+%typemap(m3wrapintype) bool,               const bool *,               const bool &               "BOOLEAN"
+%typemap(m3wrapintype) char,               const char *,               const char &               "CHAR"
+%typemap(m3wrapintype) signed char,        const signed char *,        const signed char &        "CHAR"
+%typemap(m3wrapintype) unsigned char,      const unsigned char *,      const unsigned char &      "CHAR"
+%typemap(m3wrapintype) short,              const short *,              const short &              "INTEGER"
+%typemap(m3wrapintype) unsigned short,     const unsigned short *,     const unsigned short &     "CARDINAL"
+%typemap(m3wrapintype) int,                const int *,                const int &                "INTEGER"
+%typemap(m3wrapintype) unsigned int,       const unsigned int *,       const unsigned int &       "CARDINAL"
+%typemap(m3wrapintype) long,               const long *,               const long &               "INTEGER"
+%typemap(m3wrapintype) unsigned long,      const unsigned long *,      const unsigned long &      "CARDINAL"
+%typemap(m3wrapintype) long long,          const long long *,          const long long &          "INTEGER"
+%typemap(m3wrapintype) unsigned long long, const unsigned long long *, const unsigned long long & "CARDINAL"
+%typemap(m3wrapintype) float,              const float *,              const float &              "REAL"
+%typemap(m3wrapintype) double,             const double *,             const double &             "LONGREAL"
+%typemap(m3wrapintype) long double,        const long double *,        const long double &        "EXTENDED"
+%typemap(m3wrapintype) const char *, const char []   "TEXT"
+%typemap(m3wrapintype,numinputs=0) void              ""
+%typemap(m3wrapintype) FILE            "Cstdio.FILE";
+%typemap(m3wrapintype) FILE *          "Cstdio.FILE_star";
+
+
+%typemap(m3wrapouttype) bool,               bool *,               bool &                  "BOOLEAN"
+%typemap(m3wrapouttype) char,               char *,               char &                  "CHAR"
+%typemap(m3wrapouttype) signed char,        signed char *,        signed char &           "CHAR"
+%typemap(m3wrapouttype) unsigned char,      unsigned char *,      unsigned char &         "CHAR"
+%typemap(m3wrapouttype) short,              short *,              short &                 "INTEGER"
+%typemap(m3wrapouttype) unsigned short,     unsigned short *,     unsigned short &        "CARDINAL"
+%typemap(m3wrapouttype) int,                int *,                int &                   "INTEGER"
+%typemap(m3wrapouttype) unsigned int,       unsigned int *,       unsigned int &          "CARDINAL"
+%typemap(m3wrapouttype) long,               long *,               long &                  "INTEGER"
+%typemap(m3wrapouttype) unsigned long,      unsigned long *,      unsigned long &         "CARDINAL"
+%typemap(m3wrapouttype) long long,          long long *,          long long &             "INTEGER"
+%typemap(m3wrapouttype) unsigned long long, unsigned long long *, unsigned long long &    "CARDINAL"
+%typemap(m3wrapouttype) float,              float *,              float &                 "REAL"
+%typemap(m3wrapouttype) double,             double *,             double &                "LONGREAL"
+%typemap(m3wrapouttype) long double,        long double *,        long double &           "EXTENDED"
+%typemap(m3wrapouttype) char *, char []    "TEXT"
+%typemap(m3wrapouttype,numinputs=0) void   ""
+
+%typemap(m3wraprettype) bool,               const bool &               "BOOLEAN"
+%typemap(m3wraprettype) char,               const char &               "CHAR"
+%typemap(m3wraprettype) signed char,        const signed char &        "CHAR"
+%typemap(m3wraprettype) unsigned char,      const unsigned char &      "CHAR"
+%typemap(m3wraprettype) short,              const short &              "INTEGER"
+%typemap(m3wraprettype) unsigned short,     const unsigned short &     "CARDINAL"
+%typemap(m3wraprettype) int,                const int &                "INTEGER"
+%typemap(m3wraprettype) unsigned int,       const unsigned int &       "CARDINAL"
+%typemap(m3wraprettype) long,               const long &               "INTEGER"
+%typemap(m3wraprettype) unsigned long,      const unsigned long &      "CARDINAL"
+%typemap(m3wraprettype) long long,          const long long &          "INTEGER"
+%typemap(m3wraprettype) unsigned long long, const unsigned long long & "CARDINAL"
+%typemap(m3wraprettype) float,              const float &              "REAL"
+%typemap(m3wraprettype) double,             const double &             "LONGREAL"
+%typemap(m3wraprettype) long double,        const long double &        "EXTENDED"
+%typemap(m3wraprettype) char *                                         "TEXT"
+%typemap(m3wraprettype) void                                           ""
+%typemap(m3wraprettype) FILE            "Cstdio.FILE";
+%typemap(m3wraprettype) FILE *          "Cstdio.FILE_star";
+
+
+%typemap(ctype)          char[ANY]               "char *"
+%typemap(m3rawtype)      char[ANY]               "C.char_star"
+%typemap(m3rawintype)    char[ANY]               "C.char_star"
+%typemap(m3rawrettype)   char[ANY]               "C.char_star"
+%typemap(m3wraptype)     char[ANY]               "TEXT"
+%typemap(m3wrapintype)   char[ANY]               "TEXT"
+%typemap(m3wrapouttype)  char[ANY]               "TEXT"
+%typemap(m3wraprettype)  char[ANY]               "TEXT"
+
+%typemap(m3wrapinmode)  const char * %{%}
+%typemap(m3wrapargvar)  const char * %{$1 : C.char_star;%}
+%typemap(m3wrapinconv)  const char * %{$1 := M3toC.SharedTtoS($1_name);%}
+%typemap(m3wrapfreearg) const char * %{M3toC.FreeSharedS($1_name,$1);%}
+%typemap(m3wrapargraw)  const char * %{$1%}
+%typemap("m3wrapargvar:import")  const char * "Ctypes AS C"
+%typemap("m3wrapinconv:import")  const char * "M3toC"
+%typemap("m3wrapfreearg:import") const char * "M3toC"
+
+%typemap(m3wrapretvar)  char * %{result : C.char_star;%}
+%typemap(m3wrapretraw)  char * %{result%}
+%typemap(m3wrapretconv) char * %{M3toC.CopyStoT(result)%}
+%typemap("m3wrapretvar:import")  char * "Ctypes AS C"
+%typemap("m3wrapretconv:import") char * "M3toC"
+
+%typemap(m3wrapinmode)  FILE * %{%}
+
+
+%typemap("m3wraptype:import")
+  FILE,   FILE *
+    "Cstdio";
+
+%typemap("m3wrapintype:import")
+  FILE,   FILE *
+    "Cstdio";
+
+%typemap("m3wraprettype:import")
+  FILE,   FILE *
+    "Cstdio";
+
+
+/* Composed types */
+%typemap(ctype)                SWIGTYPE "$1_type"
+%typemap(m3rawtype)            SWIGTYPE "$1_basetype"
+%typemap(m3rawrettype)         SWIGTYPE "UNTRACED REF $1_basetype"
+%typemap(m3wraptype)           SWIGTYPE "$1_basetype"
+%typemap(m3wrapintype)         SWIGTYPE "$1_basetype"
+%typemap(m3wrapouttype)        SWIGTYPE "$1_basetype"
+%typemap(m3wraprettype)        SWIGTYPE "$1_basetype"
+
+%typemap(ctype)                SWIGTYPE [] "$1_type"
+%typemap(m3rawtype)      const SWIGTYPE [] "UNTRACED REF ARRAY INTEGER OF $1_basetype"
+%typemap(m3rawtype)            SWIGTYPE [] "UNTRACED REF ARRAY INTEGER OF $1_basetype"
+%typemap(m3rawintype)    const SWIGTYPE [] "(*ARRAY OF*) $1_basetype"
+%typemap(m3rawinmode)    const SWIGTYPE [] "READONLY"
+%typemap(m3rawintype)          SWIGTYPE [] "(*ARRAY OF*) $1_basetype"
+%typemap(m3rawinmode)          SWIGTYPE [] "VAR"
+%typemap(m3rawrettype)   const SWIGTYPE [] "UNTRACED REF ARRAY INTEGER OF $1_basetype"
+%typemap(m3rawrettype)         SWIGTYPE [] "UNTRACED REF ARRAY INTEGER OF $1_basetype"
+%typemap(m3wraptype)           SWIGTYPE [] "$1_basetype"
+%typemap(m3wrapintype)   const SWIGTYPE [] "ARRAY OF $1_basetype"
+%typemap(m3wrapinmode)   const SWIGTYPE [] "READONLY"
+%typemap(m3wrapintype)         SWIGTYPE [] "ARRAY OF $1_basetype"
+%typemap(m3wrapinmode)         SWIGTYPE [] "VAR"
+%typemap(m3wrapouttype)        SWIGTYPE [] "ARRAY OF $1_basetype"
+%typemap(m3wraprettype)        SWIGTYPE [] "REF ARRAY OF $1_basetype"
+
+%typemap(ctype)                SWIGTYPE * "$1_type"
+%typemap(m3rawtype)      const SWIGTYPE * "UNTRACED REF $1_basetype"
+%typemap(m3rawtype)            SWIGTYPE * "UNTRACED REF $1_basetype"
+%typemap(m3rawintype)    const SWIGTYPE * "$1_basetype"
+%typemap(m3rawinmode)    const SWIGTYPE * "READONLY"
+%typemap(m3rawintype)          SWIGTYPE * "$1_basetype"
+%typemap(m3rawinmode)          SWIGTYPE * "VAR"
+%typemap(m3rawrettype)   const SWIGTYPE * "UNTRACED REF $1_basetype"
+%typemap(m3rawrettype)         SWIGTYPE * "UNTRACED REF $1_basetype"
+%typemap(m3wraptype)           SWIGTYPE * "$1_basetype"
+%typemap(m3wrapintype)   const SWIGTYPE * "$1_basetype"
+%typemap(m3wrapinmode)   const SWIGTYPE * "READONLY"
+%typemap(m3wrapintype)         SWIGTYPE * "$1_basetype"
+%typemap(m3wrapinmode)         SWIGTYPE * "VAR"
+%typemap(m3wrapouttype)        SWIGTYPE * "$1_basetype"
+%typemap(m3wraprettype)        SWIGTYPE * "UNTRACED REF $1_basetype"
+
+%typemap(ctype)                SWIGTYPE & "$1_type"
+%typemap(m3rawtype)      const SWIGTYPE & "UNTRACED REF $1_basetype"
+%typemap(m3rawtype)            SWIGTYPE & "UNTRACED REF $1_basetype"
+%typemap(m3rawintype)    const SWIGTYPE & "$1_basetype"
+%typemap(m3rawinmode)    const SWIGTYPE & "READONLY"
+%typemap(m3rawintype)          SWIGTYPE & "$1_basetype"
+%typemap(m3rawinmode)          SWIGTYPE & "VAR"
+%typemap(m3rawrettype)   const SWIGTYPE & "UNTRACED REF $1_basetype"
+%typemap(m3rawrettype)         SWIGTYPE & "UNTRACED REF $1_basetype"
+%typemap(m3wraptype)           SWIGTYPE & "$1_basetype"
+%typemap(m3wrapintype)   const SWIGTYPE & "$1_basetype"
+%typemap(m3wrapinmode)   const SWIGTYPE & "READONLY"
+%typemap(m3wrapintype)         SWIGTYPE & "$1_basetype"
+%typemap(m3wrapinmode)         SWIGTYPE & "VAR"
+%typemap(m3wrapouttype)        SWIGTYPE & "$1_basetype"
+%typemap(m3wraprettype)        SWIGTYPE & "UNTRACED REF $1_basetype"
+
+%typemap(ctype)                SWIGTYPE && "$1_type"
+%typemap(m3rawtype)      const SWIGTYPE && "UNTRACED REF $1_basetype"
+%typemap(m3rawtype)            SWIGTYPE && "UNTRACED REF $1_basetype"
+%typemap(m3rawintype)    const SWIGTYPE && "$1_basetype"
+%typemap(m3rawinmode)    const SWIGTYPE && "READONLY"
+%typemap(m3rawintype)          SWIGTYPE && "$1_basetype"
+%typemap(m3rawinmode)          SWIGTYPE && "VAR"
+%typemap(m3rawrettype)   const SWIGTYPE && "UNTRACED REF $1_basetype"
+%typemap(m3rawrettype)         SWIGTYPE && "UNTRACED REF $1_basetype"
+%typemap(m3wraptype)           SWIGTYPE && "$1_basetype"
+%typemap(m3wrapintype)   const SWIGTYPE && "$1_basetype"
+%typemap(m3wrapinmode)   const SWIGTYPE && "READONLY"
+%typemap(m3wrapintype)         SWIGTYPE && "$1_basetype"
+%typemap(m3wrapinmode)         SWIGTYPE && "VAR"
+%typemap(m3wrapouttype)        SWIGTYPE && "$1_basetype"
+%typemap(m3wraprettype)        SWIGTYPE && "UNTRACED REF $1_basetype"
+
+%typemap(ctype)           enum SWIGTYPE "$1_type"
+%typemap(m3rawtype)       enum SWIGTYPE "C.int"
+%typemap(m3rawintype)     enum SWIGTYPE "C.int (* $1_type *)"
+%typemap(m3rawrettype)    enum SWIGTYPE "C.int"
+%typemap(m3wraptype)      enum SWIGTYPE "$*1_type"
+%typemap(m3wrapintype)    enum SWIGTYPE "$1_type"
+%typemap(m3wrapouttype)   enum SWIGTYPE "$1_type"
+%typemap(m3wraprettype)   enum SWIGTYPE "$*1_type"
+
+/* pointer to a class member */
+%typemap(ctype)      SWIGTYPE (CLASS::*) "$1_type"
+%typemap(m3rawtype)  SWIGTYPE (CLASS::*) "REFANY"
+%typemap(m3wraptype) SWIGTYPE (CLASS::*) "$1_basetype"
+
+/* The following are the in, out, freearg, argout 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(in) char, 
+             signed char, 
+             unsigned char, 
+             short, 
+             unsigned short, 
+             int, 
+             unsigned int, 
+             long, 
+             unsigned long, 
+             long long, 
+             unsigned long long, 
+             float, 
+             double, 
+             enum SWIGTYPE
+%{ $1 = ($1_ltype)$input; %}
+
+%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 = $1; %}
+%typemap(out) long long          %{ $result = $1; %}
+%typemap(out) unsigned long long %{ $result = $1; %}
+%typemap(out) float              %{ $result = $1; %}
+%typemap(out) double             %{ $result = $1; %}
+%typemap(out) enum SWIGTYPE      %{ $result = $1; %}
+
+/* char * - treat as String */
+%typemap(in) char * {
+  $1 = $input;
+}
+//%typemap(freearg) char * { if ($1) JCALL2(ReleaseStringUTFChars, jenv, $input, $1); }
+//%typemap(out) char * { if($1) $result = JCALL1(NewStringUTF, jenv, $1); }
+
+%typemap(out) void ""
+
+/* primitive types by const reference */
+%typemap(in) const bool & (bool temp)
+%{ temp = $input ? true : false; 
+   $1 = &temp; %}
+
+%typemap(in) const char & (char temp), 
+             const signed char & (signed char temp), 
+             const unsigned char & (unsigned char temp), 
+             const short & (short temp), 
+             const unsigned short & (unsigned short temp), 
+             const int & (int temp), 
+             const unsigned int & (unsigned int temp), 
+             const long & (long temp), 
+             const unsigned long & (unsigned long temp), 
+             const long long & ($*1_ltype temp), 
+             const unsigned long long & ($*1_ltype temp), 
+             const float & (float temp), 
+             const double & (double temp)
+%{ temp = ($*1_ltype)$input; 
+$1 = &temp; %}
+
+%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 = *$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) SWIGTYPE ($&1_type argp)
+%{ argp = *($&1_ltype*)&$input; 
+   if (!argp) {
+//     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null $1_type");
+     RETURN $null;
+   }
+   $1 = *argp; %}
+%typemap(out) SWIGTYPE 
+#ifdef __cplusplus
+%{*($&1_ltype*)&$result = new $1_ltype((const $1_ltype &)$1); %}
+#else
+{
+  $&1_ltype $1ptr = ($&1_ltype) malloc(sizeof($1_ltype));
+  memmove($1ptr, &$1, sizeof($1_type));
+  *($&1_ltype*)&$result = $1ptr;
+}
+#endif
+
+/* Generic pointers and references */
+%typemap(in) SWIGTYPE *, SWIGTYPE (CLASS::*) %{ $1 = *($&1_ltype)&$input; %}
+%typemap(in) SWIGTYPE & %{ $1 = *($&1_ltype)&$input;
+  if(!$1) {
+    //SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null");
+    RETURN $null;
+  } %}
+%typemap(in) SWIGTYPE && %{ $1 = *($&1_ltype)&$input;
+  if(!$1) {
+    //SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null");
+    RETURN $null;
+  } %}
+%typemap(out) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE (CLASS::*) %{ *($&1_ltype)&$result = $1; %} 
+
+
+/* Default array handling */
+%typemap(in) SWIGTYPE [] %{ $1 = *($&1_ltype)&$input; %}
+%typemap(out) SWIGTYPE [] %{ *($&1_ltype)&$result = $1; %} 
+
+/* char[ANY] - treat as String */
+%typemap(in) char[ANY] { 
+    $1 = $input;
+}
+
+%typemap(argout) char[ANY] ""
+%typemap(freearg) char[ANY] ""//{ if ($1) JCALL2(ReleaseStringUTFChars, jenv, $input, $1); }
+%typemap(out) char[ANY] { if($1) $result = $1; }
+
+
+/* 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) /* Java boolean */
+    bool,
+    const bool &
+    ""
+
+%typecheck(SWIG_TYPECHECK_CHAR) /* Java char */
+    char, 
+    const char &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT8) /* Java byte */
+    signed char,
+    const signed char &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT16) /* Java short */
+    unsigned char, 
+    short, 
+    const unsigned char &, 
+    const short &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT32) /* Java int */
+    unsigned short, 
+    int, 
+    long, 
+    const unsigned short &, 
+    const int &, 
+    const long &,
+    enum SWIGTYPE
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT64) /* Java long */
+    unsigned int, 
+    unsigned long, 
+    long long, 
+    const unsigned int &, 
+    const unsigned long &, 
+    const long long &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT128) /* Java BigInteger */
+    unsigned long long
+    ""
+
+%typecheck(SWIG_TYPECHECK_FLOAT) /* Java float */
+    float,
+    const float &
+    ""
+
+%typecheck(SWIG_TYPECHECK_DOUBLE) /* Java double */
+    double,
+    const double &
+    ""
+
+%typecheck(SWIG_TYPECHECK_STRING) /* Java String */
+    char *,
+    char[ANY]
+    ""
+
+%typecheck(SWIG_TYPECHECK_POINTER) /* Default */
+    SWIGTYPE, 
+    SWIGTYPE *, 
+    SWIGTYPE &, 
+    SWIGTYPE &&, 
+    SWIGTYPE [],
+    SWIGTYPE (CLASS::*)
+    ""
+
+/* Exception handling */
+
+%typemap(throws) 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_JavaThrowException(jenv, SWIG_JavaRuntimeException, error_msg);
+  RETURN $null;
+}
+
+%typemap(throws) SWIGTYPE {
+  (void)$1;
+  SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown");
+  RETURN $null;
+}
+
+%typemap(throws) char * {
+  SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1);
+  RETURN $null;
+}
+
+
+/* Typemaps for code generation in proxy classes and C# type wrapper classes */
+
+/* The in 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(m3in)     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 &,
+                 char *,
+                 char[ANY],
+                 enum SWIGTYPE 
+    "$input"
+%typemap(m3in) SWIGTYPE "$&*1_type.getCPtr($input)"
+%typemap(m3in) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) "$1_basetype.getCPtr($input)"
+
+/* The m3out 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. */
+%typemap(m3out)   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 &,
+                  char *,
+                  char[ANY],
+                  enum SWIGTYPE
+%{$imcall%}
+
+%typemap(m3out) void %{$imcall%}
+
+%typemap(m3out) SWIGTYPE %{
+    RETURN NEW(REF $1_basetype, $imcall);
+%}
+%typemap(m3out) SWIGTYPE & %{
+    RETURN NEW($1_basetype, $imcall, $owner);
+%}
+%typemap(m3out) SWIGTYPE && %{
+    RETURN NEW($1_basetype, $imcall, $owner);
+%}
+%typemap(m3out) SWIGTYPE *, SWIGTYPE [], SWIGTYPE (CLASS::*) %{
+    cPtr := $imcall;
+    RETURN (cPtr = IntPtr.Zero) ? null : NEW($1_basetype, cPtr, $owner);
+%}
+
+/* Properties */
+%typemap(m3varin) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) %{
+PROCEDURE Set$var (value: $vartype) =
+  BEGIN
+    $imcall;
+  END Set$var;
+%}
+
+%typemap(m3varout) 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 &,
+                   char *,
+                   char[ANY],
+                   enum SWIGTYPE %{
+PROCEDURE Get$var (): $vartype =
+  BEGIN
+    RETURN $imcall;
+  END Get$var;
+%}
+
+%typemap(m3varout) void %{
+    get {
+      $imcall;
+    } %}
+%typemap(m3varout) SWIGTYPE %{
+    get {
+      RETURN new $&*1_mangle($imcall, true);
+    } %}
+%typemap(m3varout) SWIGTYPE & %{
+    get {
+      RETURN new $1_basetype($imcall, $owner);
+    } %}
+%typemap(m3varout) SWIGTYPE && %{
+    get {
+      RETURN new $1_basetype($imcall, $owner);
+    } %}
+%typemap(m3varout) SWIGTYPE *, SWIGTYPE [], SWIGTYPE (CLASS::*) %{
+    get {
+      IntPtr cPtr = $imcall;
+      RETURN (cPtr == IntPtr.Zero) ? null : new $1_basetype(cPtr, $owner);
+    } %}
+
+/* Typemaps used for the generation of proxy and type wrapper class code */
+%typemap(m3base)                      SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+%typemap(m3classmodifiers)            SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) "public"
+%typemap(m3code)                      SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+%typemap(m3imports)                   SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) "using System;"
+%typemap(m3interfaces)                SWIGTYPE "IDisposable"
+%typemap(m3interfaces_derived)                  SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+%typemap(m3ptrconstructormodifiers) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) "internal"
+
+%typemap(m3finalize) SWIGTYPE %{
+  ~$1_basetype() {
+    Dispose();
+  }
+%}
+
+%typemap(m3destruct, methodname="Dispose") SWIGTYPE {
+    if(swigCPtr != IntPtr.Zero && swigCMemOwn) {
+      $imcall;
+      swigCMemOwn = false;
+    }
+    swigCPtr = IntPtr.Zero;
+    GC.SuppressFinalize(this);
+  }
+
+%typemap(m3destruct_derived, methodname="Dispose") SWIGTYPE {
+    if(swigCPtr != IntPtr.Zero && swigCMemOwn) {
+      $imcall;
+      swigCMemOwn = false;
+    }
+    swigCPtr = IntPtr.Zero;
+    GC.SuppressFinalize(this);
+    base.Dispose();
+  }
+
+%typemap(m3getcptr) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) %{
+  internal static IntPtr getCPtr($1_basetype obj) {
+    RETURN (obj == null) ? IntPtr.Zero : obj.swigCPtr;
+  }
+%}
+
+/* M3 specific directives */
+#define %m3multiretval        %feature("modula3:multiretval")
+#define %constnumeric(num)    %feature("constnumeric","num")
+
+%pragma(modula3) moduleimports=%{
+IMPORT BlaBla;
+%}
+
+%pragma(modula3) imclassimports=%{
+FROM BlaBla IMPORT Bla;
+%}
+
+/* Some ANSI C typemaps */
+
+%apply unsigned long { size_t };
+
+/* Array reference typemaps */
+%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) }
+
+/* const pointers */
+%apply SWIGTYPE * { SWIGTYPE *const }
+
diff --git a/share/swig/2.0.11/modula3/modula3head.swg b/share/swig/3.0.12/modula3/modula3head.swg
index af96a78..af96a78 100644
--- a/share/swig/2.0.11/modula3/modula3head.swg
+++ b/share/swig/3.0.12/modula3/modula3head.swg
diff --git a/share/swig/2.0.11/modula3/typemaps.i b/share/swig/3.0.12/modula3/typemaps.i
index 1d76ab5..1d76ab5 100644
--- a/share/swig/2.0.11/modula3/typemaps.i
+++ b/share/swig/3.0.12/modula3/typemaps.i
diff --git a/share/swig/2.0.11/mzscheme/mzrun.swg b/share/swig/3.0.12/mzscheme/mzrun.swg
index 06447d7..06447d7 100644
--- a/share/swig/2.0.11/mzscheme/mzrun.swg
+++ b/share/swig/3.0.12/mzscheme/mzrun.swg
diff --git a/share/swig/2.0.11/mzscheme/mzscheme.swg b/share/swig/3.0.12/mzscheme/mzscheme.swg
index 9ae2428..9ae2428 100644
--- a/share/swig/2.0.11/mzscheme/mzscheme.swg
+++ b/share/swig/3.0.12/mzscheme/mzscheme.swg
diff --git a/share/swig/3.0.12/mzscheme/std_common.i b/share/swig/3.0.12/mzscheme/std_common.i
new file mode 100644
index 0000000..a83e273
--- /dev/null
+++ b/share/swig/3.0.12/mzscheme/std_common.i
@@ -0,0 +1,23 @@
+/* -----------------------------------------------------------------------------
+ * std_common.i
+ *
+ * SWIG typemaps for STL - common utilities
+ * ----------------------------------------------------------------------------- */
+
+%include <std/std_except.i>
+
+%apply size_t { std::size_t };
+
+%{
+#include <string>
+
+SWIGINTERNINLINE
+std::string swig_scm_to_string(Scheme_Object *x) {
+    return std::string(SCHEME_STR_VAL(x));
+}
+
+SWIGINTERNINLINE
+Scheme_Object *swig_make_string(const std::string &s) {
+    return scheme_make_string(s.c_str());
+}
+%}
diff --git a/share/swig/2.0.11/php/std_deque.i b/share/swig/3.0.12/mzscheme/std_deque.i
index cb98f6c..cb98f6c 100644
--- a/share/swig/2.0.11/php/std_deque.i
+++ b/share/swig/3.0.12/mzscheme/std_deque.i
diff --git a/share/swig/2.0.11/mzscheme/std_map.i b/share/swig/3.0.12/mzscheme/std_map.i
index 849f8ba..849f8ba 100644
--- a/share/swig/2.0.11/mzscheme/std_map.i
+++ b/share/swig/3.0.12/mzscheme/std_map.i
diff --git a/share/swig/2.0.11/mzscheme/std_pair.i b/share/swig/3.0.12/mzscheme/std_pair.i
index d5a6547..d5a6547 100644
--- a/share/swig/2.0.11/mzscheme/std_pair.i
+++ b/share/swig/3.0.12/mzscheme/std_pair.i
diff --git a/share/swig/2.0.11/mzscheme/std_string.i b/share/swig/3.0.12/mzscheme/std_string.i
index b19e856..b19e856 100644
--- a/share/swig/2.0.11/mzscheme/std_string.i
+++ b/share/swig/3.0.12/mzscheme/std_string.i
diff --git a/share/swig/2.0.11/mzscheme/std_vector.i b/share/swig/3.0.12/mzscheme/std_vector.i
index 22e1fa9..22e1fa9 100644
--- a/share/swig/2.0.11/mzscheme/std_vector.i
+++ b/share/swig/3.0.12/mzscheme/std_vector.i
diff --git a/share/swig/2.0.11/mzscheme/stl.i b/share/swig/3.0.12/mzscheme/stl.i
index b19eae5..b19eae5 100644
--- a/share/swig/2.0.11/mzscheme/stl.i
+++ b/share/swig/3.0.12/mzscheme/stl.i
diff --git a/share/swig/3.0.12/mzscheme/typemaps.i b/share/swig/3.0.12/mzscheme/typemaps.i
new file mode 100644
index 0000000..9346349
--- /dev/null
+++ b/share/swig/3.0.12/mzscheme/typemaps.i
@@ -0,0 +1,367 @@
+/* -----------------------------------------------------------------------------
+ * typemaps.i
+ * ----------------------------------------------------------------------------- */
+
+/* The MzScheme module handles all types uniformly via typemaps. Here
+   are the definitions.  */
+
+/* Pointers */
+
+%typemap(in) SWIGTYPE * {
+  $1 = ($ltype) SWIG_MustGetPtr($input, $descriptor, $argnum, 0);
+}
+
+%typemap(in) void * {
+  $1 = SWIG_MustGetPtr($input, NULL, $argnum, 0);
+}
+
+%typemap(varin) SWIGTYPE * {
+  $1 = ($ltype) SWIG_MustGetPtr($input, $descriptor, 1, 0);
+}
+
+%typemap(varin) SWIGTYPE & {
+  $1 = *(($1_ltype)SWIG_MustGetPtr($input, $descriptor, 1, 0));
+}
+
+%typemap(varin) SWIGTYPE && {
+  $1 = *(($1_ltype)SWIG_MustGetPtr($input, $descriptor, 1, 0));
+}
+
+%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 * {
+  $result = SWIG_NewPointerObj ($1, $descriptor, $owner);
+}
+
+%typemap(out) SWIGTYPE *DYNAMIC {
+  swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor,(void **) &$1);
+  $result = SWIG_NewPointerObj ($1, ty, $owner);
+}
+    
+%typemap(varout) SWIGTYPE *, SWIGTYPE [] {
+  $result = SWIG_NewPointerObj ($1, $descriptor, 0);
+}
+
+%typemap(varout) SWIGTYPE & {
+  $result = SWIG_NewPointerObj((void *) &$1, $1_descriptor, 0);
+}
+
+%typemap(varout) SWIGTYPE && {
+  $result = SWIG_NewPointerObj((void *) &$1, $1_descriptor, 0);
+}
+
+/* C++ References */
+
+#ifdef __cplusplus
+
+%typemap(in) SWIGTYPE &, SWIGTYPE && { 
+  $1 = ($ltype) SWIG_MustGetPtr($input, $descriptor, $argnum, 0);
+  if ($1 == NULL) scheme_signal_error("swig-type-error (null reference)");
+}
+
+%typemap(out) SWIGTYPE &, SWIGTYPE && {
+  $result = SWIG_NewPointerObj ($1, $descriptor, $owner);
+}
+
+%typemap(out) SWIGTYPE &DYNAMIC {
+  swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor,(void **) &$1);
+  $result = SWIG_NewPointerObj ($1, ty, $owner);
+}
+
+#endif
+
+/* Arrays */
+
+%typemap(in) SWIGTYPE[] {
+  $1 = ($ltype) SWIG_MustGetPtr($input, $descriptor, $argnum, 0);
+}
+
+%typemap(out) SWIGTYPE[] {
+  $result = SWIG_NewPointerObj ($1, $descriptor, $owner);
+}
+
+/* Enums */
+%typemap(in) enum SWIGTYPE {
+  if (!SWIG_is_integer($input)) 
+      scheme_wrong_type(FUNC_NAME, "integer", $argnum - 1, argc, argv);
+  $1 = ($1_type) SWIG_convert_int($input);
+}
+
+%typemap(varin) enum SWIGTYPE {
+  if (!SWIG_is_integer($input)) 
+      scheme_wrong_type(FUNC_NAME, "integer", 0, argc, argv);
+  $1 = ($1_type) SWIG_convert_int($input);
+}
+
+%typemap(out) enum SWIGTYPE "$result = scheme_make_integer_value($1);";
+%typemap(varout) enum SWIGTYPE "$result = scheme_make_integer_value($1);";
+
+
+/* Pass-by-value */
+
+%typemap(in) SWIGTYPE($&1_ltype argp) {
+  argp = ($&1_ltype) SWIG_MustGetPtr($input, $&1_descriptor, $argnum, 0);
+  $1 = *argp;
+}
+
+%typemap(varin) SWIGTYPE {
+  $&1_ltype argp;
+  argp = ($&1_ltype) SWIG_MustGetPtr($input, $&1_descriptor, 1, 0);
+  $1 = *argp;
+}
+
+
+%typemap(out) SWIGTYPE 
+#ifdef __cplusplus
+{
+  $&1_ltype resultptr;
+  resultptr = new $1_ltype(($1_ltype &) $1);
+  $result =  SWIG_NewPointerObj (resultptr, $&1_descriptor, 1);
+} 
+#else
+{
+  $&1_ltype resultptr;
+  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;
+  resultptr = new $1_ltype(($1_ltype &) $1);
+  $result =  SWIG_NewPointerObj (resultptr, $&1_descriptor, 0);
+} 
+#else
+{
+  $&1_ltype resultptr;
+  resultptr = ($&1_ltype) malloc(sizeof($1_type));
+  memmove(resultptr, &$1, sizeof($1_type));
+  $result = SWIG_NewPointerObj(resultptr, $&1_descriptor, 0);
+}
+#endif
+
+/* The SIMPLE_MAP macro below defines the whole set of typemaps needed
+   for simple types. */
+
+%define SIMPLE_MAP(C_NAME, MZ_PREDICATE, MZ_TO_C, C_TO_MZ, MZ_NAME)
+%typemap(in) C_NAME {
+    if (!MZ_PREDICATE($input))
+	scheme_wrong_type(FUNC_NAME, #MZ_NAME, $argnum - 1, argc, argv);
+    $1 = MZ_TO_C($input);
+}
+%typemap(varin) C_NAME {
+    if (!MZ_PREDICATE($input))
+	scheme_wrong_type(FUNC_NAME, #MZ_NAME, 0, argc, argv);
+    $1 = MZ_TO_C($input);
+}
+%typemap(out) C_NAME {
+    $result = C_TO_MZ($1);
+}
+%typemap(varout) C_NAME {
+    $result = C_TO_MZ($1);
+}
+%typemap(in) C_NAME *INPUT (C_NAME temp) {
+    temp = (C_NAME) MZ_TO_C($input);
+    $1 = &temp;
+}
+%typemap(in,numinputs=0) C_NAME *OUTPUT (C_NAME temp) {
+    $1 = &temp;
+}
+%typemap(argout) C_NAME *OUTPUT {
+    Scheme_Object *s;
+    s = C_TO_MZ(*$1);
+    SWIG_APPEND_VALUE(s);
+}
+%typemap(in) C_NAME *BOTH = C_NAME *INPUT;
+%typemap(argout) C_NAME *BOTH = C_NAME *OUTPUT;
+%typemap(in) C_NAME *INOUT = C_NAME *INPUT;
+%typemap(argout) C_NAME *INOUT = C_NAME *OUTPUT;
+%enddef
+
+SIMPLE_MAP(bool, SCHEME_BOOLP, SCHEME_TRUEP,
+	   swig_make_boolean, boolean);
+SIMPLE_MAP(char, SCHEME_CHARP, SCHEME_CHAR_VAL,
+	   scheme_make_character, character);
+SIMPLE_MAP(unsigned char, SCHEME_CHARP, SCHEME_CHAR_VAL,
+	   scheme_make_character, character);
+SIMPLE_MAP(int, SWIG_is_integer, SWIG_convert_int,
+	   scheme_make_integer_value, integer);
+SIMPLE_MAP(short, SWIG_is_integer, SWIG_convert_short,
+	   scheme_make_integer_value, integer);
+SIMPLE_MAP(long, SWIG_is_integer, SWIG_convert_long,
+	   scheme_make_integer_value, integer);
+SIMPLE_MAP(ptrdiff_t, SWIG_is_integer, SWIG_convert_long,
+	   scheme_make_integer_value, integer);
+SIMPLE_MAP(unsigned int, SWIG_is_unsigned_integer, SWIG_convert_unsigned_int,
+	   scheme_make_integer_value_from_unsigned, integer);
+SIMPLE_MAP(unsigned short, SWIG_is_unsigned_integer, SWIG_convert_unsigned_short,
+	   scheme_make_integer_value_from_unsigned, integer);
+SIMPLE_MAP(unsigned long, SWIG_is_unsigned_integer, SWIG_convert_unsigned_long,
+	   scheme_make_integer_value_from_unsigned, integer);
+SIMPLE_MAP(size_t, SWIG_is_unsigned_integer, SWIG_convert_unsigned_long,
+	   scheme_make_integer_value_from_unsigned, integer);
+SIMPLE_MAP(float, SCHEME_REALP, scheme_real_to_double,
+	   scheme_make_double, real);
+SIMPLE_MAP(double, SCHEME_REALP, scheme_real_to_double,
+	   scheme_make_double, real);
+
+SIMPLE_MAP(char *, SCHEME_STRINGP, SCHEME_STR_VAL, 
+	   SCHEME_MAKE_STRING, string);
+SIMPLE_MAP(const char *, SCHEME_STRINGP, SCHEME_STR_VAL, 
+	   SCHEME_MAKE_STRING, string);
+
+/* For MzScheme 30x:  Use these typemaps if you are not going to use
+   UTF8 encodings in your C code. 
+ SIMPLE_MAP(char *,SCHEME_BYTE_STRINGP, SCHEME_BYTE_STR_VAL,
+ 	   scheme_make_byte_string_without_copying,bytestring);
+ SIMPLE_MAP(const char *,SCHEME_BYTE_STRINGP, SCHEME_BYTE_STR_VAL,
+ 	   scheme_make_byte_string_without_copying,bytestring);
+*/
+
+/* Const primitive references.  Passed by value */
+
+%define REF_MAP(C_NAME, MZ_PREDICATE, MZ_TO_C, C_TO_MZ, MZ_NAME)
+  %typemap(in) const C_NAME & (C_NAME temp) {
+     if (!MZ_PREDICATE($input))
+        scheme_wrong_type(FUNC_NAME, #MZ_NAME, $argnum - 1, argc, argv);
+     temp = MZ_TO_C($input);
+     $1 = &temp;
+  }
+  %typemap(out) const C_NAME & {
+    $result = C_TO_MZ(*$1);
+  }
+%enddef
+
+REF_MAP(bool, SCHEME_BOOLP, SCHEME_TRUEP,
+	   swig_make_boolean, boolean);
+REF_MAP(char, SCHEME_CHARP, SCHEME_CHAR_VAL,
+	   scheme_make_character, character);
+REF_MAP(unsigned char, SCHEME_CHARP, SCHEME_CHAR_VAL,
+	   scheme_make_character, character);
+REF_MAP(int, SWIG_is_integer, SWIG_convert_int,
+	   scheme_make_integer_value, integer);
+REF_MAP(short, SWIG_is_integer, SWIG_convert_short,
+	   scheme_make_integer_value, integer);
+REF_MAP(long, SWIG_is_integer, SWIG_convert_long,
+	   scheme_make_integer_value, integer);
+REF_MAP(unsigned int, SWIG_is_unsigned_integer, SWIG_convert_unsigned_int,
+	   scheme_make_integer_value_from_unsigned, integer);
+REF_MAP(unsigned short, SWIG_is_unsigned_integer, SWIG_convert_unsigned_short,
+	   scheme_make_integer_value_from_unsigned, integer);
+REF_MAP(unsigned long, SWIG_is_unsigned_integer, SWIG_convert_unsigned_long,
+	   scheme_make_integer_value_from_unsigned, integer);
+REF_MAP(float, SCHEME_REALP, scheme_real_to_double,
+	   scheme_make_double, real);
+REF_MAP(double, SCHEME_REALP, scheme_real_to_double,
+	   scheme_make_double, real);
+
+/* Void */
+
+%typemap(out) void "$result = scheme_void;";
+
+/* Pass through Scheme_Object * */
+
+%typemap (in) Scheme_Object * "$1=$input;";
+%typemap (out) Scheme_Object * "$result=$1;";
+%typecheck(SWIG_TYPECHECK_POINTER) Scheme_Object * "$1=1;";
+
+
+/* ------------------------------------------------------------
+ * String & length
+ * ------------------------------------------------------------ */
+
+//%typemap(in) (char *STRING, int LENGTH) {
+//    int temp;
+//    $1 = ($1_ltype) SWIG_Guile_scm2newstr($input, &temp);
+//    $2 = ($2_ltype) temp;
+//}
+
+
+/* ------------------------------------------------------------
+ * Typechecking rules
+ * ------------------------------------------------------------ */
+
+%typecheck(SWIG_TYPECHECK_INTEGER)
+	 int, short, long,
+ 	 unsigned int, unsigned short, unsigned long,
+	 signed char, unsigned char,
+	 long long, unsigned long long,
+	 const int &, const short &, const long &,
+ 	 const unsigned int &, const unsigned short &, const unsigned long &,
+	 const long long &, const unsigned long long &,
+	 enum SWIGTYPE
+{
+  $1 = (SWIG_is_integer($input)) ? 1 : 0;
+}
+
+%typecheck(SWIG_TYPECHECK_BOOL) bool, bool &, const bool &
+{
+  $1 = (SCHEME_BOOLP($input)) ? 1 : 0;
+}
+
+%typecheck(SWIG_TYPECHECK_DOUBLE)
+	float, double,
+	const float &, const double &
+{
+  $1 = (SCHEME_REALP($input)) ? 1 : 0;
+}
+
+%typecheck(SWIG_TYPECHECK_STRING) char {
+  $1 = (SCHEME_STRINGP($input)) ? 1 : 0;
+}
+
+%typecheck(SWIG_TYPECHECK_STRING) char * {
+  $1 = (SCHEME_STRINGP($input)) ? 1 : 0;
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] {
+  void *ptr;
+  if (SWIG_ConvertPtr($input, (void **) &ptr, $1_descriptor, 0)) {
+    $1 = 0;
+  } else {
+    $1 = 1;
+  }
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE {
+  void *ptr;
+  if (SWIG_ConvertPtr($input, (void **) &ptr, $&1_descriptor, 0)) {
+    $1 = 0;
+  } else {
+    $1 = 1;
+  }
+}
+
+%typecheck(SWIG_TYPECHECK_VOIDPTR) void * {
+  void *ptr;
+  if (SWIG_ConvertPtr($input, (void **) &ptr, 0, 0)) {
+    $1 = 0;
+  } else {
+    $1 = 1;
+  }
+}
+
+
+/* Array reference typemaps */
+%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) }
+
+/* const pointers */
+%apply SWIGTYPE * { SWIGTYPE *const }
+
+
diff --git a/share/swig/2.0.11/ocaml/carray.i b/share/swig/3.0.12/ocaml/carray.i
index bbf1ddd..bbf1ddd 100644
--- a/share/swig/2.0.11/ocaml/carray.i
+++ b/share/swig/3.0.12/ocaml/carray.i
diff --git a/share/swig/2.0.11/ocaml/class.swg b/share/swig/3.0.12/ocaml/class.swg
index 0ee304c..0ee304c 100644
--- a/share/swig/2.0.11/ocaml/class.swg
+++ b/share/swig/3.0.12/ocaml/class.swg
diff --git a/share/swig/2.0.11/ocaml/cstring.i b/share/swig/3.0.12/ocaml/cstring.i
index 0d6aa4b..0d6aa4b 100644
--- a/share/swig/2.0.11/ocaml/cstring.i
+++ b/share/swig/3.0.12/ocaml/cstring.i
diff --git a/share/swig/3.0.12/ocaml/director.swg b/share/swig/3.0.12/ocaml/director.swg
new file mode 100644
index 0000000..158cbfe
--- /dev/null
+++ b/share/swig/3.0.12/ocaml/director.swg
@@ -0,0 +1,101 @@
+/* -----------------------------------------------------------------------------
+ * director.swg
+ *
+ * This file contains support for director classes so that Ocaml proxy
+ * methods can be called from C++.
+ * ----------------------------------------------------------------------------- */
+
+#include <string>
+#include <exception>
+
+# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG)
+
+namespace Swig {
+  /* base class for director exceptions */
+  class DirectorException : public std::exception {
+    protected:
+      std::string swig_msg;
+
+    public:
+      DirectorException(const char *msg="") : swig_msg(msg) {
+      }
+
+      virtual ~DirectorException() throw() {
+      }
+
+      const char *what() const throw() {
+        return swig_msg.c_str();
+      }
+  };
+
+  /* type mismatch in the return value from a Ocaml method call */
+  class DirectorTypeMismatchException : public DirectorException {
+    public:
+      DirectorTypeMismatchException(const char *msg="") : DirectorException(msg) {
+      }
+  };
+
+  /* any Ocaml exception that occurs during a director method call */
+  class DirectorMethodException : public DirectorException {};
+
+  /* attempt to call a pure virtual method via a director method */
+  class DirectorPureVirtualException : public DirectorException {
+    public:
+      DirectorPureVirtualException(const char *msg="") : DirectorException(msg) {
+      }
+
+      static void raise(const char *msg) {
+        throw DirectorPureVirtualException(msg);
+      }
+  };
+
+  /* simple thread abstraction for pthreads on win32 */
+#ifdef __THREAD__
+#define __PTHREAD__
+#if defined(_WIN32) || defined(__WIN32__)
+#define pthread_mutex_lock EnterCriticalSection
+#define pthread_mutex_unlock LeaveCriticalSection
+#define pthread_mutex_t CRITICAL_SECTION
+#define MUTEX_INIT(var) CRITICAL_SECTION var
+#else
+#include <pthread.h>
+#define MUTEX_INIT(var) pthread_mutex_t var = PTHREAD_MUTEX_INITIALIZER
+#endif
+#endif
+
+  /* director base class */
+  class Director {
+    private:
+      /* pointer to the wrapped ocaml object */
+      CAML_VALUE swig_self;
+      /* flag indicating whether the object is owned by ocaml or c++ */
+      mutable bool swig_disown_flag;
+
+    public:
+      /* wrap a ocaml object. */
+      Director(CAML_VALUE self) : swig_self(self), swig_disown_flag(false) {
+        register_global_root(&swig_self);
+      }
+
+      /* discard our reference at destruction */
+      virtual ~Director() {
+        remove_global_root(&swig_self);
+        swig_disown();
+        // Disown is safe here because we're just divorcing a reference that points to us.
+      }
+
+      /* return a pointer to the wrapped ocaml object */
+      CAML_VALUE swig_get_self() const {
+	  return swig_self;
+      }
+
+      /* acquire ownership of the wrapped ocaml object (the sense of "disown" is from ocaml) */
+      void swig_disown() const {
+        if (!swig_disown_flag) {
+          swig_disown_flag=true;
+          callback(*caml_named_value("caml_obj_disown"),swig_self);
+        }
+      }
+  };
+}
+
diff --git a/share/swig/2.0.11/ocaml/ocaml.i b/share/swig/3.0.12/ocaml/ocaml.i
index e099f7c..e099f7c 100644
--- a/share/swig/2.0.11/ocaml/ocaml.i
+++ b/share/swig/3.0.12/ocaml/ocaml.i
diff --git a/share/swig/2.0.11/ocaml/ocaml.swg b/share/swig/3.0.12/ocaml/ocaml.swg
index a00252b..a00252b 100644
--- a/share/swig/2.0.11/ocaml/ocaml.swg
+++ b/share/swig/3.0.12/ocaml/ocaml.swg
diff --git a/share/swig/3.0.12/ocaml/ocamldec.swg b/share/swig/3.0.12/ocaml/ocamldec.swg
new file mode 100644
index 0000000..96e1cd2
--- /dev/null
+++ b/share/swig/3.0.12/ocaml/ocamldec.swg
@@ -0,0 +1,167 @@
+/* -----------------------------------------------------------------------------
+ * ocamldec.swg
+ *
+ * Ocaml runtime code -- declarations
+ * ----------------------------------------------------------------------------- */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#ifdef __cplusplus
+#define SWIGEXT extern "C"
+SWIGEXT {
+#else
+#define SWIGEXT 
+#endif
+#define value caml_value_t
+#define CAML_VALUE caml_value_t
+#include <caml/alloc.h>
+#include <caml/custom.h>
+#include <caml/mlvalues.h>
+#include <caml/memory.h>
+#include <caml/callback.h>
+#include <caml/fail.h>
+#include <caml/misc.h>
+
+#define caml_array_set swig_caml_array_set
+
+// Adapted from memory.h and mlvalues.h
+
+#define SWIG_CAMLlocal1(x) \
+  caml_value_t x = 0; \
+  CAMLxparam1 (x)
+
+#define SWIG_CAMLlocal2(x, y) \
+  caml_value_t x = 0, y = 0; \
+  CAMLxparam2 (x, y)
+
+#define SWIG_CAMLlocal3(x, y, z) \
+  caml_value_t x = 0, y = 0, z = 0; \
+  CAMLxparam3 (x, y, z)
+
+#define SWIG_CAMLlocal4(x, y, z, t) \
+  caml_value_t x = 0, y = 0, z = 0, t = 0; \
+  CAMLxparam4 (x, y, z, t)
+
+#define SWIG_CAMLlocal5(x, y, z, t, u) \
+  caml_value_t x = 0, y = 0, z = 0, t = 0, u = 0; \
+  CAMLxparam5 (x, y, z, t, u)
+
+#define SWIG_CAMLlocalN(x, size) \
+  caml_value_t x [(size)] = { 0, /* 0, 0, ... */ }; \
+  CAMLxparamN (x, (size))
+
+#define SWIG_Field(x, i) (((caml_value_t *)(x)) [i])           /* Also an l-value. */
+#define SWIG_Store_field(block, offset, val) do{ \
+  mlsize_t caml__temp_offset = (offset); \
+  caml_value_t caml__temp_val = (val); \
+  modify (&SWIG_Field ((block), caml__temp_offset), caml__temp_val); \
+}while(0)
+
+#define SWIG_Data_custom_val(v) ((void *) &SWIG_Field((v), 1))
+#ifdef ARCH_BIG_ENDIAN
+#define SWIG_Tag_val(val) (((unsigned char *) (val)) [-1])
+                                                 /* Also an l-value. */
+#define SWIG_Tag_hp(hp) (((unsigned char *) (hp)) [sizeof(caml_value_t)-1])
+                                                 /* Also an l-value. */
+#else
+#define SWIG_Tag_val(val) (((unsigned char *) (val)) [-sizeof(caml_value_t)])
+                                                 /* Also an l-value. */
+#define SWIG_Tag_hp(hp) (((unsigned char *) (hp)) [0])
+                                                 /* Also an l-value. */
+#endif
+
+#ifdef CAMLreturn0
+#undef CAMLreturn0
+#endif
+#define CAMLreturn0 do{ \
+  caml_local_roots = caml__frame; \
+  return; \
+}while (0)
+
+#ifdef CAMLreturn
+#undef CAMLreturn
+#endif
+#define CAMLreturn(result) do{ \
+  caml_value_t caml__temp_result = (result); \
+  caml_local_roots = caml__frame; \
+  return (caml__temp_result); \
+}while(0)
+
+#define CAMLreturn_type(result) do{ \
+  caml_local_roots = caml__frame; \
+  return result; \
+}while(0)
+
+#ifdef CAMLnoreturn
+#undef CAMLnoreturn
+#endif
+#define CAMLnoreturn ((void) caml__frame)
+
+
+#ifndef ARCH_ALIGN_INT64
+#define SWIG_Int64_val(v) (*((int64 *) SWIG_Data_custom_val(v)))
+#else
+CAMLextern int64 Int64_val(caml_value_t v);
+#define SWIG_Int64_val(v) Int64_val(v)
+#endif
+
+#define SWIG_NewPointerObj(p,type,flags) caml_val_ptr(p,type)
+#define SWIG_GetModule(clientdata) SWIG_Ocaml_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) SWIG_Ocaml_SetModule(pointer)
+
+#define SWIG_contract_assert(expr, msg) if(!(expr)) {failwith(msg);} else
+
+    SWIGSTATIC int
+    SWIG_GetPtr(void *source, void **result, swig_type_info *type, swig_type_info *result_type);
+    
+    SWIGSTATIC void *
+    SWIG_MustGetPtr (CAML_VALUE v,  swig_type_info *type);
+    
+    SWIGSTATIC CAML_VALUE _wrap_delete_void( CAML_VALUE );
+    
+    SWIGSTATIC int enum_to_int( char *name, CAML_VALUE v );
+    SWIGSTATIC CAML_VALUE int_to_enum( char *name, int v );
+
+    SWIGSTATIC CAML_VALUE caml_list_nth( CAML_VALUE lst, int n );
+    SWIGSTATIC CAML_VALUE caml_list_append( CAML_VALUE lst, CAML_VALUE elt );
+    SWIGSTATIC int caml_list_length( CAML_VALUE lst );
+    SWIGSTATIC CAML_VALUE caml_array_new( int n );
+    SWIGSTATIC void caml_array_set( CAML_VALUE arr, int n, CAML_VALUE item );
+    SWIGSTATIC CAML_VALUE caml_array_nth( CAML_VALUE arr, int n );
+    SWIGSTATIC int caml_array_len( CAML_VALUE arr );
+
+    SWIGSTATIC CAML_VALUE caml_val_char( char c );
+    SWIGSTATIC CAML_VALUE caml_val_uchar( unsigned char c );
+
+    SWIGSTATIC CAML_VALUE caml_val_short( short s );
+    SWIGSTATIC CAML_VALUE caml_val_ushort( unsigned short s );
+    
+    SWIGSTATIC CAML_VALUE caml_val_int( int x );
+    SWIGSTATIC CAML_VALUE caml_val_uint( unsigned int x );
+
+    SWIGSTATIC CAML_VALUE caml_val_long( long x );
+    SWIGSTATIC CAML_VALUE caml_val_ulong( unsigned long x );
+
+    SWIGSTATIC CAML_VALUE caml_val_float( float f );
+    SWIGSTATIC CAML_VALUE caml_val_double( double d );
+
+    SWIGSTATIC CAML_VALUE caml_val_ptr( void *p, swig_type_info *descriptor );
+
+    SWIGSTATIC CAML_VALUE caml_val_string( const char *str );
+    SWIGSTATIC CAML_VALUE caml_val_string_len( const char *str, int len );
+
+    SWIGSTATIC long caml_long_val( CAML_VALUE v );
+    SWIGSTATIC double caml_double_val( CAML_VALUE v );
+
+    SWIGSTATIC int caml_ptr_val_internal( CAML_VALUE v, void **out,
+				      swig_type_info *descriptor );
+    SWIGSTATIC void *caml_ptr_val( CAML_VALUE v, swig_type_info *descriptor );
+
+    SWIGSTATIC char *caml_string_val( CAML_VALUE v );
+    SWIGSTATIC int caml_string_len( CAML_VALUE v );
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/share/swig/2.0.11/ocaml/ocamlkw.swg b/share/swig/3.0.12/ocaml/ocamlkw.swg
index 92d8222..92d8222 100644
--- a/share/swig/2.0.11/ocaml/ocamlkw.swg
+++ b/share/swig/3.0.12/ocaml/ocamlkw.swg
diff --git a/share/swig/2.0.11/ocaml/preamble.swg b/share/swig/3.0.12/ocaml/preamble.swg
index 39374ce..39374ce 100644
--- a/share/swig/2.0.11/ocaml/preamble.swg
+++ b/share/swig/3.0.12/ocaml/preamble.swg
diff --git a/share/swig/3.0.12/ocaml/std_common.i b/share/swig/3.0.12/ocaml/std_common.i
new file mode 100644
index 0000000..6523af0
--- /dev/null
+++ b/share/swig/3.0.12/ocaml/std_common.i
@@ -0,0 +1,22 @@
+/* -----------------------------------------------------------------------------
+ * std_common.i
+ *
+ * SWIG typemaps for STL - common utilities
+ * ----------------------------------------------------------------------------- */
+
+%include <std/std_except.i>
+
+%apply size_t { std::size_t };
+
+%{
+#include <string>
+SWIGINTERNINLINE
+CAML_VALUE SwigString_FromString(const std::string &s) {
+  return caml_val_string((char *)s.c_str());
+}
+
+SWIGINTERNINLINE
+std::string SwigString_AsString(CAML_VALUE o) {
+  return std::string((char *)caml_ptr_val(o,0));
+}
+%}
diff --git a/share/swig/2.0.11/ocaml/std_complex.i b/share/swig/3.0.12/ocaml/std_complex.i
index 5192261..5192261 100644
--- a/share/swig/2.0.11/ocaml/std_complex.i
+++ b/share/swig/3.0.12/ocaml/std_complex.i
diff --git a/share/swig/2.0.11/ocaml/std_deque.i b/share/swig/3.0.12/ocaml/std_deque.i
index 5b38962..5b38962 100644
--- a/share/swig/2.0.11/ocaml/std_deque.i
+++ b/share/swig/3.0.12/ocaml/std_deque.i
diff --git a/share/swig/2.0.11/ocaml/std_list.i b/share/swig/3.0.12/ocaml/std_list.i
index 06181cc..06181cc 100644
--- a/share/swig/2.0.11/ocaml/std_list.i
+++ b/share/swig/3.0.12/ocaml/std_list.i
diff --git a/share/swig/2.0.11/ocaml/std_map.i b/share/swig/3.0.12/ocaml/std_map.i
index 5656b7f..5656b7f 100644
--- a/share/swig/2.0.11/ocaml/std_map.i
+++ b/share/swig/3.0.12/ocaml/std_map.i
diff --git a/share/swig/2.0.11/php/std_pair.i b/share/swig/3.0.12/ocaml/std_pair.i
index fe45ee6..fe45ee6 100644
--- a/share/swig/2.0.11/php/std_pair.i
+++ b/share/swig/3.0.12/ocaml/std_pair.i
diff --git a/share/swig/2.0.11/ocaml/std_string.i b/share/swig/3.0.12/ocaml/std_string.i
index bd5be0d..bd5be0d 100644
--- a/share/swig/2.0.11/ocaml/std_string.i
+++ b/share/swig/3.0.12/ocaml/std_string.i
diff --git a/share/swig/2.0.11/ocaml/std_vector.i b/share/swig/3.0.12/ocaml/std_vector.i
index 53d1074..53d1074 100644
--- a/share/swig/2.0.11/ocaml/std_vector.i
+++ b/share/swig/3.0.12/ocaml/std_vector.i
diff --git a/share/swig/2.0.11/ocaml/stl.i b/share/swig/3.0.12/ocaml/stl.i
index 9d2e91e..9d2e91e 100644
--- a/share/swig/2.0.11/ocaml/stl.i
+++ b/share/swig/3.0.12/ocaml/stl.i
diff --git a/share/swig/2.0.11/ocaml/swig.ml b/share/swig/3.0.12/ocaml/swig.ml
index 5dc2de7..5dc2de7 100644
--- a/share/swig/2.0.11/ocaml/swig.ml
+++ b/share/swig/3.0.12/ocaml/swig.ml
diff --git a/share/swig/2.0.11/ocaml/swig.mli b/share/swig/3.0.12/ocaml/swig.mli
index 3207b9e..3207b9e 100644
--- a/share/swig/2.0.11/ocaml/swig.mli
+++ b/share/swig/3.0.12/ocaml/swig.mli
diff --git a/share/swig/3.0.12/ocaml/swigp4.ml b/share/swig/3.0.12/ocaml/swigp4.ml
new file mode 100644
index 0000000..2f6074a
--- /dev/null
+++ b/share/swig/3.0.12/ocaml/swigp4.ml
@@ -0,0 +1,135 @@
+open Camlp4
+  
+module Id : Sig.Id = 
+struct 
+  let name = "swigp4" 
+  let version = "0.1" 
+end 
+  
+module Make (Syntax : Sig.Camlp4Syntax) = 
+struct 
+  open Sig 
+  include Syntax 
+
+  let _loc = Loc.ghost
+  let lap x y = x :: y
+  let c_ify e loc = 	  
+    match e with
+        <:expr< $int:_$ >> -> <:expr< (C_int $e$) >>
+      | <:expr< $str:_$ >> -> <:expr< (C_string $e$) >>
+      | <:expr< $chr:_$ >> -> <:expr< (C_char $e$) >>
+      | <:expr< $flo:_$ >> -> <:expr< (C_double $e$) >>
+      | <:expr< True    >> -> <:expr< (C_bool $e$) >>
+      | <:expr< False   >> -> <:expr< (C_bool $e$) >>
+      | _ -> <:expr< $e$ >>
+        let mk_list args loc f =
+          let rec mk_list_inner args loc f =
+            match args with
+	              [] -> <:expr< [] >>
+              | x :: xs ->
+	              (let loc = Ast.loc_of_expr x in
+	               <:expr< [ ($f x _loc$) ] @ ($mk_list_inner xs loc f$) >>) in
+          match args with
+	            [] -> <:expr< (Obj.magic C_void) >>
+            | [ a ] -> <:expr< (Obj.magic $f a _loc$) >>
+            | _ -> <:expr< (Obj.magic (C_list ($mk_list_inner args loc f$))) >> ;;
+  
+  EXTEND Gram
+    GLOBAL: expr;
+
+    expr: LEVEL "top"
+    [ [ e1 = expr ; "'" ; "[" ; e2 = expr ; "]" ->
+	  <:expr< (invoke $e1$) "[]" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "->" ; l = LIDENT ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" ->
+	    <:expr< (invoke $e1$) $str:l$ ($mk_list args _loc c_ify$) >>
+      | e1 = expr ; "->" ; u = UIDENT ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" ->
+	    <:expr< (invoke $e1$) $str:u$ ($mk_list args _loc c_ify$) >>
+      | e1 = expr ; "->" ; s = expr LEVEL "simple" ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" ->
+	    <:expr< (invoke $e1$) $s$ ($mk_list args _loc c_ify$) >>
+      | e1 = expr ; "'" ; "." ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" ->
+	    <:expr< (invoke $e1$) "()" ($mk_list args _loc c_ify$) >>
+      | e1 = expr ; "'" ; "->" ; l = LIDENT ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" ->
+	    <:expr< (invoke ((invoke $e1$) "->" C_void)) $str:l$ ($mk_list args _loc c_ify$) >>
+      | e1 = expr ; "'" ; "->" ; u = UIDENT ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" ->
+	    <:expr< (invoke ((invoke $e1$) "->" C_void)) $str:u$ ($mk_list args _loc c_ify$) >>
+      | e1 = expr ; "'" ; "->" ; s = expr LEVEL "simple" ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" ->
+	    <:expr< (invoke ((invoke $e1$) "->" C_void)) $s$ ($mk_list args _loc c_ify$) >>
+      | e1 = expr ; "'" ; "++" ->
+	    <:expr< (invoke $e1$) "++" C_void >>
+      | e1 = expr ; "'" ; "--" ->
+	    <:expr< (invoke $e1$) "--" C_void >>
+      | e1 = expr ; "'" ; "-" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "-" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "+" ; e2 = expr -> <:expr< (invoke $e1$) "+" (C_list [ $c_ify e2 _loc$ ])  >> 
+      | e1 = expr ; "'" ; "*" ; e2 = expr -> <:expr< (invoke $e1$) "*" (C_list [ $c_ify e2 _loc$ ])  >> 
+      | "'" ; "&" ; e1 = expr -> 
+	    <:expr< (invoke $e1$) "&" C_void >> 
+      | "'" ; "!" ; e1 = expr ->
+	    <:expr< (invoke $e1$) "!" C_void >>
+      | "'" ; "~" ; e1 = expr ->
+	    <:expr< (invoke $e1$) "~" C_void >>
+      | e1 = expr ; "'" ; "/" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "/" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "%" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "%" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "lsl" ; e2 = expr ->
+	    <:expr< (invoke $e1$) ("<" ^ "<") (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "lsr" ; e2 = expr ->
+	    <:expr< (invoke $e1$) (">" ^ ">") (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "<" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "<" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "<=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "<=" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; ">" ; e2 = expr ->
+	    <:expr< (invoke $e1$) ">" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; ">=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) ">=" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "==" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "==" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "!=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "!=" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "&" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "&" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "^" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "^" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "|" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "|" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "&&" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "&&" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "||" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "||" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "=" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "+=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "+=" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "-=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "-=" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "*=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "*=" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "/=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "/=" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "%=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "%=" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "lsl" ; "=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) ("<" ^ "<=") (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "lsr" ; "=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) (">" ^ ">=") (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "&=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "&=" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "^=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "^=" (C_list [ $c_ify e2 _loc$ ]) >> 
+      | e1 = expr ; "'" ; "|=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "|=" (C_list [ $c_ify e2 _loc$ ]) >>
+      | "'" ; e = expr -> c_ify e _loc
+      | c = expr ; "as" ; id = LIDENT -> <:expr< $lid:"get_" ^ id$ $c$ >>
+      | c = expr ; "to" ; id = LIDENT -> <:expr< $uid:"C_" ^ id$ $c$ >>
+      | "`" ; "`" ; l = LIDENT -> <:expr< C_enum `$lid:l$ >>
+      | "`" ; "`" ; u = UIDENT -> <:expr< C_enum `$uid:u$ >>
+      | f = expr ; "'" ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" -> 
+	    <:expr< $f$ ($mk_list args _loc c_ify$) >>
+      ] ] ;
+    END ;;
+  
+end 
+  
+module M = Register.OCamlSyntaxExtension(Id)(Make)
diff --git a/share/swig/3.0.12/ocaml/typecheck.i b/share/swig/3.0.12/ocaml/typecheck.i
new file mode 100644
index 0000000..a13e155
--- /dev/null
+++ b/share/swig/3.0.12/ocaml/typecheck.i
@@ -0,0 +1,176 @@
+/* -----------------------------------------------------------------------------
+ * typecheck.i
+ *
+ * Typechecking rules
+ * ----------------------------------------------------------------------------- */
+
+%typecheck(SWIG_TYPECHECK_INTEGER) char, signed char, const char &, const signed char & {
+  if( !Is_block($input) ) $1 = 0;
+  else {
+      switch( SWIG_Tag_val($input) ) {
+      case C_char: $1 = 1; break;
+      default: $1 = 0; break;
+      }
+  }
+}
+
+%typecheck(SWIG_TYPECHECK_INTEGER) unsigned char, const unsigned char & {
+  if( !Is_block($input) ) $1 = 0;
+  else {
+      switch( SWIG_Tag_val($input) ) {
+      case C_uchar: $1 = 1; break;
+      default: $1 = 0; break;
+      }
+  }
+}
+
+%typecheck(SWIG_TYPECHECK_INTEGER) short, signed short, const short &, const signed short &, wchar_t {
+  if( !Is_block($input) ) $1 = 0;
+  else {
+      switch( SWIG_Tag_val($input) ) {
+      case C_short: $1 = 1; break;
+      default: $1 = 0; break;
+      }
+  }
+}
+
+%typecheck(SWIG_TYPECHECK_INTEGER) unsigned short, const unsigned short & {
+  if( !Is_block($input) ) $1 = 0;
+  else {
+      switch( SWIG_Tag_val($input) ) {
+      case C_ushort: $1 = 1; break;
+      default: $1 = 0; break;
+      }
+  }
+}
+
+// XXX arty 
+// Will move enum SWIGTYPE later when I figure out what to do with it...
+
+%typecheck(SWIG_TYPECHECK_INTEGER) int, signed int, const int &, const signed int &, enum SWIGTYPE {
+  if( !Is_block($input) ) $1 = 0;
+  else {
+      switch( SWIG_Tag_val($input) ) {
+      case C_int: $1 = 1; break;
+      default: $1 = 0; break;
+      }
+  }
+}
+
+%typecheck(SWIG_TYPECHECK_INTEGER) unsigned int, const unsigned int & {
+  if( !Is_block($input) ) $1 = 0;
+  else {
+      switch( SWIG_Tag_val($input) ) {
+      case C_uint: $1 = 1; break;
+      case C_int32: $1 = 1; break;
+      default: $1 = 0; break;
+      }
+  }
+}
+
+%typecheck(SWIG_TYPECHECK_INTEGER) long, signed long, unsigned long, long long, signed long long, unsigned long long, const long &, const signed long &, const unsigned long &, const long long &, const signed long long &, const unsigned long long & {
+  if( !Is_block($input) ) $1 = 0;
+  else {
+      switch( SWIG_Tag_val($input) ) {
+      case C_int64: $1 = 1; break;
+      default: $1 = 0; break;
+      }
+  }
+}
+
+%typecheck(SWIG_TYPECHECK_INTEGER) bool, oc_bool, BOOL, const bool &, const oc_bool &, const BOOL & {
+  if( !Is_block($input) ) $1 = 0;
+  else {
+      switch( SWIG_Tag_val($input) ) {
+      case C_bool: $1 = 1; break;
+      default: $1 = 0; break;
+      }
+  }
+}
+
+%typecheck(SWIG_TYPECHECK_DOUBLE) float, const float & {
+  if( !Is_block($input) ) $1 = 0;
+  else {
+      switch( SWIG_Tag_val($input) ) {
+      case C_float: $1 = 1; break;
+      default: $1 = 0; break;
+      }
+  }  
+}
+
+%typecheck(SWIG_TYPECHECK_DOUBLE) double, const double & {
+  if( !Is_block($input) ) $1 = 0;
+  else {
+      switch( SWIG_Tag_val($input) ) {
+      case C_double: $1 = 1; break;
+      default: $1 = 0; break;
+      }
+  }  
+}
+
+%typecheck(SWIG_TYPECHECK_STRING) char * {
+  if( !Is_block($input) ) $1 = 0;
+  else {
+      switch( SWIG_Tag_val($input) ) {
+      case C_string: $1 = 1; break;
+      case C_ptr: {
+	swig_type_info *typeinfo = 
+	    (swig_type_info *)(long)SWIG_Int64_val(SWIG_Field($input,1));
+	$1 = SWIG_TypeCheck("char *",typeinfo) ||
+	     SWIG_TypeCheck("signed char *",typeinfo) ||
+	     SWIG_TypeCheck("unsigned char *",typeinfo) ||
+	     SWIG_TypeCheck("const char *",typeinfo) ||
+	     SWIG_TypeCheck("const signed char *",typeinfo) ||
+	     SWIG_TypeCheck("const unsigned char *",typeinfo) ||
+	     SWIG_TypeCheck("std::string",typeinfo);
+      } break;
+      default: $1 = 0; break;
+      }
+  }    
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] {
+  void *ptr;
+  $1 = !caml_ptr_val_internal($input, &ptr,$descriptor);
+}
+
+#if 0
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE {
+  void *ptr;
+  $1 = !caml_ptr_val_internal($input, &ptr, $&1_descriptor);
+}
+
+#endif
+
+%typecheck(SWIG_TYPECHECK_VOIDPTR) void * {
+  void *ptr;
+  $1 = !caml_ptr_val_internal($input, &ptr, 0);
+}
+
+/* ------------------------------------------------------------
+ * Exception handling
+ * ------------------------------------------------------------ */
+
+%typemap(throws) int, 
+                  long, 
+                  short, 
+                  unsigned int, 
+                  unsigned long, 
+                  unsigned short {
+  SWIG_exception($1,"Thrown exception from C++ (int)");
+}
+
+%typemap(throws) SWIGTYPE CLASS {
+  $&1_ltype temp = new $1_ltype($1);
+  SWIG_exception((int)temp,"Thrown exception from C++ (object)");
+}
+
+%typemap(throws) SWIGTYPE {
+  (void)$1;
+  SWIG_exception(0,"Thrown exception from C++ (unknown)");
+}
+
+%typemap(throws) char * {
+  SWIG_exception(0,$1);
+}
diff --git a/share/swig/3.0.12/ocaml/typemaps.i b/share/swig/3.0.12/ocaml/typemaps.i
new file mode 100644
index 0000000..7602ad6
--- /dev/null
+++ b/share/swig/3.0.12/ocaml/typemaps.i
@@ -0,0 +1,371 @@
+/* -----------------------------------------------------------------------------
+ * typemaps.i
+ *
+ * The Ocaml module handles all types uniformly via typemaps. Here
+ * are the definitions.
+ * ----------------------------------------------------------------------------- */
+
+/* Pointers */
+
+%typemap(in) void ""
+
+%typemap(out) void "$result = Val_int(0);"
+
+%typemap(in) void * {
+    $1 = caml_ptr_val($input,$descriptor);
+}
+
+%typemap(varin) void * {
+    $1 = ($ltype)caml_ptr_val($input,$descriptor);
+}
+
+%typemap(out) void * {
+    $result = caml_val_ptr($1,$descriptor);
+}
+
+%typemap(varout) void * {
+    $result = caml_val_ptr($1,$descriptor);
+}
+
+#ifdef __cplusplus
+
+%typemap(in) SWIGTYPE & {
+    /* %typemap(in) SWIGTYPE & */
+    $1 = ($ltype) caml_ptr_val($input,$1_descriptor);
+}
+
+%typemap(in) SWIGTYPE && {
+    /* %typemap(in) SWIGTYPE && */
+    $1 = ($ltype) caml_ptr_val($input,$1_descriptor);
+}
+
+%typemap(varin) SWIGTYPE & {
+    /* %typemap(varin) SWIGTYPE & */
+    $1 = *(($ltype) caml_ptr_val($input,$1_descriptor));
+}
+
+%typemap(varin) SWIGTYPE && {
+    /* %typemap(varin) SWIGTYPE && */
+    $1 = *(($ltype) caml_ptr_val($input,$1_descriptor));
+}
+
+%typemap(out) SWIGTYPE & {
+    /* %typemap(out) SWIGTYPE & */
+    CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr");
+    if( fromval ) {
+	$result = callback(*fromval,caml_val_ptr((void *) &$1,$1_descriptor));
+    } else {
+	$result = caml_val_ptr ((void *) &$1,$1_descriptor);
+    }
+}
+
+%typemap(out) SWIGTYPE && {
+    /* %typemap(out) SWIGTYPE && */
+    CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr");
+    if( fromval ) {
+	$result = callback(*fromval,caml_val_ptr((void *) &$1,$1_descriptor));
+    } else {
+	$result = caml_val_ptr ((void *) &$1,$1_descriptor);
+    }
+}
+
+#if 0
+%typemap(argout) SWIGTYPE & {
+    CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr");
+    if( fromval ) {
+	swig_result =
+	    caml_list_append(swig_result,
+			     callback(*fromval,caml_val_ptr((void *) $1,
+							    $1_descriptor)));
+    } else {
+	swig_result =
+	    caml_list_append(swig_result,
+			     caml_val_ptr ((void *) $1,$1_descriptor));
+    }
+}
+%typemap(argout) SWIGTYPE && {
+    CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr");
+    if( fromval ) {
+	swig_result =
+	    caml_list_append(swig_result,
+			     callback(*fromval,caml_val_ptr((void *) $1,
+							    $1_descriptor)));
+    } else {
+	swig_result =
+	    caml_list_append(swig_result,
+			     caml_val_ptr ((void *) $1,$1_descriptor));
+    }
+}
+#endif
+
+%typemap(argout) const SWIGTYPE & { }
+%typemap(argout) const SWIGTYPE && { }
+
+%typemap(in) SWIGTYPE {
+    $1 = *(($&1_ltype) caml_ptr_val($input,$&1_descriptor)) ;
+}
+
+%typemap(out) SWIGTYPE {
+    /* %typemap(out) SWIGTYPE */
+    $&1_ltype temp = new $ltype((const $1_ltype &) $1);
+    CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr");
+    if( fromval ) {
+	$result = callback(*fromval,caml_val_ptr((void *)temp,$&1_descriptor));
+    } else {
+	$result = caml_val_ptr ((void *)temp,$&1_descriptor);
+    }
+}
+
+%typemap(in) char *& (char *temp) {
+  /* %typemap(in) char *& */
+  temp = (char*)caml_val_ptr($1,$descriptor);
+  $1 = &temp;
+}
+
+%typemap(argout) char *& {
+  /* %typemap(argout) char *& */
+  swig_result =	caml_list_append(swig_result,caml_val_string_len(*$1, strlen(*$1)));
+}
+
+#else
+
+%typemap(in) SWIGTYPE {
+    $1 = *(($&1_ltype) caml_ptr_val($input,$&1_descriptor)) ;
+}
+
+%typemap(out) SWIGTYPE {
+    /* %typemap(out) SWIGTYPE */
+    void *temp = calloc(1,sizeof($ltype));
+    CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr");
+    memmove( temp, &$1, sizeof( $1_type ) );
+    if( fromval ) {
+	$result = callback(*fromval,caml_val_ptr((void *)temp,$&1_descriptor));
+    } else {
+	$result = caml_val_ptr ((void *)temp,$&1_descriptor);
+    }
+}
+
+%apply SWIGTYPE { const SWIGTYPE & };
+%apply SWIGTYPE { const SWIGTYPE && };
+
+#endif
+
+/* The SIMPLE_MAP macro below defines the whole set of typemaps needed
+   for simple types. */
+
+%define SIMPLE_MAP(C_NAME, C_TO_MZ, MZ_TO_C)
+/* In */
+%typemap(in) C_NAME {
+    $1 = MZ_TO_C($input);
+}
+%typemap(varin) C_NAME {
+    $1 = MZ_TO_C($input);
+}
+%typemap(in) C_NAME & ($*1_ltype temp) {
+    temp = ($*1_ltype) MZ_TO_C($input);
+    $1 = &temp;
+}
+%typemap(varin) C_NAME & {
+    $1 = MZ_TO_C($input);
+}
+%typemap(directorout) C_NAME {
+    $1 = MZ_TO_C($input);
+}
+%typemap(in) C_NAME *INPUT ($*1_ltype temp) {
+    temp = ($*1_ltype) MZ_TO_C($input);
+    $1 = &temp;
+}
+%typemap(in,numinputs=0) C_NAME *OUTPUT ($*1_ltype temp) {
+    $1 = &temp;
+}
+/* Out */
+%typemap(out) C_NAME {
+    $result = C_TO_MZ($1);
+}
+%typemap(varout) C_NAME {
+    $result = C_TO_MZ($1);
+}
+%typemap(varout) C_NAME & {
+    /* %typemap(varout) C_NAME & (generic) */
+    $result = C_TO_MZ($1);
+}
+%typemap(argout) C_NAME *OUTPUT {
+    swig_result = caml_list_append(swig_result,C_TO_MZ((long)*$1));
+}
+%typemap(out) C_NAME & {
+    /* %typemap(out) C_NAME & (generic) */
+    $result = C_TO_MZ(*$1);
+}
+%typemap(argout) C_NAME & {
+    swig_result = caml_list_append(swig_result,C_TO_MZ((long)*$1));
+}
+%typemap(directorin) C_NAME {
+    args = caml_list_append(args,C_TO_MZ($1));
+}
+%enddef
+
+SIMPLE_MAP(bool, caml_val_bool, caml_long_val);
+SIMPLE_MAP(oc_bool, caml_val_bool, caml_long_val);
+SIMPLE_MAP(char, caml_val_char, caml_long_val);
+SIMPLE_MAP(signed char, caml_val_char, caml_long_val);
+SIMPLE_MAP(unsigned char, caml_val_uchar, caml_long_val);
+SIMPLE_MAP(int, caml_val_int, caml_long_val);
+SIMPLE_MAP(short, caml_val_short, caml_long_val);
+SIMPLE_MAP(wchar_t, caml_val_short, caml_long_val);
+SIMPLE_MAP(long, caml_val_long, caml_long_val);
+SIMPLE_MAP(ptrdiff_t, caml_val_int, caml_long_val);
+SIMPLE_MAP(unsigned int, caml_val_uint, caml_long_val);
+SIMPLE_MAP(unsigned short, caml_val_ushort, caml_long_val);
+SIMPLE_MAP(unsigned long, caml_val_ulong, caml_long_val);
+SIMPLE_MAP(size_t, caml_val_int, caml_long_val);
+SIMPLE_MAP(float, caml_val_float, caml_double_val);
+SIMPLE_MAP(double, caml_val_double, caml_double_val);
+SIMPLE_MAP(long long,caml_val_ulong,caml_long_val);
+SIMPLE_MAP(unsigned long long,caml_val_ulong,caml_long_val);
+
+/* Void */
+
+%typemap(out) void "$result = Val_unit;";
+
+/* Pass through value */
+
+%typemap (in) value,caml::value,CAML_VALUE "$1=$input;";
+%typemap (out) value,caml::value,CAML_VALUE "$result=$1;";
+
+/* Arrays */
+
+%typemap(in) ArrayCarrier * {
+    $1 = ($ltype)caml_ptr_val($input,$1_descriptor);
+}
+
+%typemap(out) ArrayCarrier * {
+    CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr");
+    if( fromval ) {
+	$result = callback(*fromval,caml_val_ptr((void *)$1,$1_descriptor));
+    } else {
+	$result = caml_val_ptr ((void *)$1,$1_descriptor);
+    }
+}
+
+#if 0
+%include <carray.i>
+#endif
+
+/* Handle char arrays as strings */
+
+%define %char_ptr_in(how)
+%typemap(how)  char *, signed char *, unsigned char * {
+    /* %typemap(how) char * ... */
+    $1 = ($ltype)caml_string_val($input);
+}
+/* Again work around the empty array bound bug */
+%typemap(how) char [ANY], signed char [ANY], unsigned char [ANY] {
+    /* %typemap(how) char [ANY] ... */
+    char *temp = caml_string_val($input);
+    strcpy((char *)$1,temp); 
+    /* strncpy would be better but we might not have an array size */
+}
+%enddef
+
+%char_ptr_in(in);
+%char_ptr_in(varin);
+%char_ptr_in(directorout);
+
+%define %char_ptr_out(how) 
+%typemap(how) 
+    char *, signed char *, unsigned char *, 
+    const char *, const signed char *, const unsigned char * {
+    $result = caml_val_string((char *)$1);
+}
+/* I'd like to use the length here but can't because it might be empty */
+%typemap(how)
+    char [ANY], signed char [ANY], unsigned char [ANY],
+    const char [ANY], const signed char [ANY], const unsigned char [ANY] {
+    $result = caml_val_string((char *)$1);
+}
+%enddef
+
+%char_ptr_out(out);
+%char_ptr_out(varout);
+%char_ptr_out(directorin);
+
+%define %swigtype_ptr_in(how)
+%typemap(how) SWIGTYPE * {
+    /* %typemap(how) SWIGTYPE * */
+    $1 = ($ltype)caml_ptr_val($input,$1_descriptor);
+}
+%typemap(how) SWIGTYPE (CLASS::*) {
+    /* %typemap(how) SWIGTYPE (CLASS::*) */
+    void *v = caml_ptr_val($input,$1_descriptor);
+    memcpy(& $1, &v, sizeof(v));
+}
+%enddef
+
+%define %swigtype_ptr_out(how)
+%typemap(out) SWIGTYPE * {
+    /* %typemap(how) SWIGTYPE *, SWIGTYPE (CLASS::*) */
+    CAML_VALUE *fromval = caml_named_value("create_$ntype_from_ptr");
+    if( fromval ) {
+	$result = callback(*fromval,caml_val_ptr((void *)$1,$1_descriptor));
+    } else {
+	$result = caml_val_ptr ((void *)$1,$1_descriptor);
+    }
+}
+%typemap(how) SWIGTYPE (CLASS::*) {
+    /* %typemap(how) SWIGTYPE *, SWIGTYPE (CLASS::*) */
+    void *v;
+    memcpy(&v,& $1, sizeof(void *));
+    $result = caml_val_ptr (v,$1_descriptor);
+}
+%enddef
+
+%swigtype_ptr_in(in);
+%swigtype_ptr_in(varin);
+%swigtype_ptr_in(directorout);
+%swigtype_ptr_out(out);
+%swigtype_ptr_out(varout);
+%swigtype_ptr_out(directorin);
+
+%define %swigtype_array_fail(how,msg)
+%typemap(how) SWIGTYPE [] {
+    failwith(msg);
+}
+%enddef
+
+%swigtype_array_fail(in,"Array arguments for arbitrary types need a typemap");
+%swigtype_array_fail(varin,"Assignment to global arrays for arbitrary types need a typemap");
+%swigtype_array_fail(out,"Array arguments for arbitrary types need a typemap");
+%swigtype_array_fail(varout,"Array variables need a typemap");
+%swigtype_array_fail(directorin,"Array results with arbitrary types need a typemap");
+%swigtype_array_fail(directorout,"Array arguments with arbitrary types need a typemap");
+
+/* C++ References */
+
+/* Enums */
+%define %swig_enum_in(how)
+%typemap(how) enum SWIGTYPE {
+    $1 = ($type)caml_long_val_full($input,"$type_marker");
+}
+%enddef
+
+%define %swig_enum_out(how)
+%typemap(how) enum SWIGTYPE {
+    $result = callback2(*caml_named_value(SWIG_MODULE "_int_to_enum"),*caml_named_value("$type_marker"),Val_int((int)$1));
+}
+%enddef
+
+%swig_enum_in(in)
+%swig_enum_in(varin)
+%swig_enum_in(directorout)
+%swig_enum_out(out)
+%swig_enum_out(varout)
+%swig_enum_out(directorin)
+
+
+/* Array reference typemaps */
+%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+%apply SWIGTYPE && { SWIGTYPE ((&)[ANY]) }
+
+/* const pointers */
+%apply SWIGTYPE * { SWIGTYPE *const }
+
diff --git a/share/swig/2.0.11/ocaml/typeregister.swg b/share/swig/3.0.12/ocaml/typeregister.swg
index c3ba904..c3ba904 100644
--- a/share/swig/2.0.11/ocaml/typeregister.swg
+++ b/share/swig/3.0.12/ocaml/typeregister.swg
diff --git a/share/swig/2.0.11/octave/attribute.i b/share/swig/3.0.12/octave/attribute.i
index 779716c..779716c 100644
--- a/share/swig/2.0.11/octave/attribute.i
+++ b/share/swig/3.0.12/octave/attribute.i
diff --git a/share/swig/3.0.12/octave/boost_shared_ptr.i b/share/swig/3.0.12/octave/boost_shared_ptr.i
new file mode 100644
index 0000000..e918620
--- /dev/null
+++ b/share/swig/3.0.12/octave/boost_shared_ptr.i
@@ -0,0 +1,311 @@
+%include <shared_ptr.i>
+
+// Language specific macro implementing all the customisations for handling the smart pointer
+%define SWIG_SHARED_PTR_TYPEMAPS(CONST, TYPE...)
+
+// %naturalvar is as documented for member variables
+%naturalvar TYPE;
+%naturalvar SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
+
+// destructor wrapper customisation
+%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) CONST TYPE (void *argp, int res = 0) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (!argp) {
+    %argument_nullref("$type", $symname, $argnum);
+  } else {
+    $1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
+    if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+  }
+}
+%typemap(out) CONST TYPE {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) CONST TYPE {
+  void *argp = 0;
+  int newmem = 0;
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  if (!argp) {
+    %variable_nullref("$type", "$name");
+  } else {
+    $1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
+    if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+  }
+}
+%typemap(varout) CONST TYPE {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+// plain pointer
+// Note: $disown not implemented as it will lead to a memory leak of the shared_ptr instance
+%typemap(in) CONST TYPE * (void  *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast(tempshared.get(), $1_ltype);
+  } else {
+    smartarg = %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
+  }
+}
+%typemap(out, fragment="SWIG_null_deleter") CONST TYPE * {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), $owner | SWIG_POINTER_OWN));
+}
+
+%typemap(varin) CONST TYPE * {
+  void *argp = 0;
+  int newmem = 0;
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0;
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast(tempshared.get(), $1_ltype);
+  } else {
+    smartarg = %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
+  }
+}
+%typemap(varout, fragment="SWIG_null_deleter") CONST TYPE * {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_0) : 0;
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+// plain reference
+%typemap(in) CONST TYPE & (void  *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (!argp) { %argument_nullref("$type", $symname, $argnum); }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast(tempshared.get(), $1_ltype);
+  } else {
+    $1 = %const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
+  }
+}
+%typemap(out, fragment="SWIG_null_deleter") CONST TYPE & {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner);
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) CONST TYPE & {
+  void *argp = 0;
+  int newmem = 0;
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
+  if (!argp) {
+    %variable_nullref("$type", "$name");
+  }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = *%const_cast(tempshared.get(), $1_ltype);
+  } else {
+    $1 = *%const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
+  }
+}
+%typemap(varout, fragment="SWIG_null_deleter") CONST TYPE & {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(&$1 SWIG_NO_NULL_DELETER_0);
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+// plain pointer by reference
+// Note: $disown not implemented as it will lead to a memory leak of the shared_ptr instance
+%typemap(in) TYPE *CONST& (void  *argp = 0, int res = 0, $*1_ltype temp = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    temp = %const_cast(tempshared.get(), $*1_ltype);
+  } else {
+    temp = %const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $*1_ltype);
+  }
+  $1 = &temp;
+}
+%typemap(out, fragment="SWIG_null_deleter") TYPE *CONST& {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1 SWIG_NO_NULL_DELETER_$owner);
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) TYPE *CONST& %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) TYPE *CONST& %{
+#error "varout typemap not implemented"
+%}
+
+// shared_ptr by value
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > (void *argp, int res = 0) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (argp) $1 = *(%reinterpret_cast(argp, $&ltype));
+  if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $&ltype);
+}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
+  int newmem = 0;
+  void *argp = 0;
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  $1 = argp ? *(%reinterpret_cast(argp, $&ltype)) : SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE >();
+  if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $&ltype);
+}
+%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+// shared_ptr by reference
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & (void *argp, int res = 0, $*1_ltype tempshared) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
+    delete %reinterpret_cast(argp, $ltype);
+    $1 = &tempshared;
+  } else {
+    $1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
+  }
+}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
+#error "varout typemap not implemented"
+%}
+
+// shared_ptr by pointer
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * (void *argp, int res = 0, $*1_ltype tempshared) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
+    delete %reinterpret_cast(argp, $ltype);
+    $1 = &tempshared;
+  } else {
+    $1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
+  }
+}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 && *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+  if ($owner) delete $1;
+}
+
+%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
+#error "varout typemap not implemented"
+%}
+
+// shared_ptr by pointer reference
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& (void *argp, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, $*1_ltype temp = 0) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (argp) tempshared = *%reinterpret_cast(argp, $*ltype);
+  if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $*ltype);
+  temp = &tempshared;
+  $1 = &temp;
+}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 && **$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(**$1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
+#error "varout typemap not implemented"
+%}
+
+// Typecheck typemaps
+// Note: SWIG_ConvertPtr with void ** parameter set to 0 instead of using SWIG_ConvertPtrAndOwn, so that the casting 
+// function is not called thereby avoiding a possible smart pointer copy constructor call when casting up the inheritance chain.
+%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1) 
+                      TYPE CONST,
+                      TYPE CONST &,
+                      TYPE CONST *,
+                      TYPE *CONST&,
+                      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 > *& {
+  int res = SWIG_ConvertPtr($input, 0, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), 0);
+  $1 = SWIG_CheckState(res);
+}
+
+
+// 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"
+%}
+
+
+%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
+%enddef
+
diff --git a/share/swig/2.0.11/octave/carrays.i b/share/swig/3.0.12/octave/carrays.i
index 014de37..014de37 100644
--- a/share/swig/2.0.11/octave/carrays.i
+++ b/share/swig/3.0.12/octave/carrays.i
diff --git a/share/swig/2.0.11/python/cdata.i b/share/swig/3.0.12/octave/cdata.i
index 3679659..3679659 100644
--- a/share/swig/2.0.11/python/cdata.i
+++ b/share/swig/3.0.12/octave/cdata.i
diff --git a/share/swig/2.0.11/octave/cmalloc.i b/share/swig/3.0.12/octave/cmalloc.i
index 248f06b..248f06b 100644
--- a/share/swig/2.0.11/octave/cmalloc.i
+++ b/share/swig/3.0.12/octave/cmalloc.i
diff --git a/share/swig/3.0.12/octave/director.swg b/share/swig/3.0.12/octave/director.swg
new file mode 100644
index 0000000..e80877e
--- /dev/null
+++ b/share/swig/3.0.12/octave/director.swg
@@ -0,0 +1,132 @@
+/* -----------------------------------------------------------------------------
+ * director.swg
+ *
+ * This file contains support for director classes so that Octave proxy
+ * methods can be called from C++.
+ * ----------------------------------------------------------------------------- */
+
+# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG)
+
+#include <exception>
+
+namespace Swig {
+
+  class Director {
+    octave_swig_type *self;
+    bool swig_disowned;
+
+    Director(const Director &x);
+    Director &operator=(const Director &rhs);
+  public:
+
+    Director(void *vptr):self(0), swig_disowned(false) {
+      set_rtdir(vptr, this);
+    }
+
+    ~Director() {
+      swig_director_destroyed(self, this);
+      if (swig_disowned)
+	self->decref();
+    }
+
+    void swig_set_self(octave_swig_type *new_self) {
+      assert(!swig_disowned);
+      self = new_self;
+    }
+
+    octave_swig_type *swig_get_self() const {
+      return self;
+    }
+
+    void swig_disown() {
+      if (swig_disowned)
+	return;
+      swig_disowned = true;
+      self->incref();
+    }
+  };
+
+  struct DirectorTypeMismatchException {
+    static void raise(const char *msg) {
+      // ... todo
+      throw(DirectorTypeMismatchException());
+    }
+
+    static void raise(const octave_value &ov, const char *msg) {
+      // ... todo
+      raise(msg);
+    }
+  };
+
+  struct DirectorPureVirtualException {
+    static void raise(const char *msg) {
+      // ... todo
+      throw(DirectorPureVirtualException());
+    }
+
+    static void raise(const octave_value &ov, const char *msg) {
+      // ... todo
+      raise(msg);
+    }
+  };
+
+  SWIGINTERN rtdir_map *get_rtdir_map() {
+    static swig_module_info *module = 0;
+    if (!module)
+      module = SWIG_GetModule(0);
+    if (!module)
+      return 0;
+    if (!module->clientdata)
+      module->clientdata = new rtdir_map;
+    return (rtdir_map *) module->clientdata;
+  }
+
+  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *d) {
+    rtdir_map *rm = get_rtdir_map();
+    if (rm)
+      (*rm)[vptr] = d;
+  }
+
+  SWIGINTERNINLINE void erase_rtdir(void *vptr) {
+    rtdir_map *rm = get_rtdir_map();
+    if (rm)
+      (*rm).erase(vptr);
+  }
+
+  SWIGINTERNINLINE Director *get_rtdir(void *vptr) {
+    rtdir_map *rm = get_rtdir_map();
+    if (!rm)
+      return 0;
+    rtdir_map::const_iterator pos = rm->find(vptr);
+    Director *rtdir = (pos != rm->end())? pos->second : 0;
+    return rtdir;
+  }
+
+  SWIGRUNTIME void swig_director_destroyed(octave_swig_type *self, Director *d) {
+    self->director_destroyed(d);
+  }
+
+  SWIGRUNTIME octave_swig_type *swig_director_get_self(Director *d) {
+    return d->swig_get_self();
+  }
+
+  SWIGRUNTIME void swig_director_set_self(Director *d, octave_swig_type *self) {
+    d->swig_set_self(self);
+  }
+
+}
+
+SWIGRUNTIME void swig_acquire_ownership(void *vptr) {
+  //  assert(0);
+  // ... todo
+}
+
+SWIGRUNTIME void swig_acquire_ownership_array(void *vptr) {
+  //  assert(0);
+  // ... todo
+}
+
+SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own) {
+  //  assert(0);
+  // ... todo
+}
diff --git a/share/swig/3.0.12/octave/exception.i b/share/swig/3.0.12/octave/exception.i
new file mode 100644
index 0000000..2f0f489
--- /dev/null
+++ b/share/swig/3.0.12/octave/exception.i
@@ -0,0 +1,14 @@
+%include <typemaps/exception.swg>
+
+%insert("runtime") {
+  %define_as(SWIG_exception(code, msg), %block(%error(code, msg); SWIG_fail; ))
+}
+
+%define SWIG_RETHROW_OCTAVE_EXCEPTIONS
+  /* rethrow any exceptions thrown by Octave */
+%#if SWIG_OCTAVE_PREREQ(4,2,0)
+  catch (octave::execution_exception& _e) { throw; }
+  catch (octave::exit_exception& _e) { throw; }
+  catch (octave::interrupt_exception& _e) { throw; }
+%#endif
+%enddef
diff --git a/share/swig/2.0.11/octave/factory.i b/share/swig/3.0.12/octave/factory.i
index 46a0a87..46a0a87 100644
--- a/share/swig/2.0.11/octave/factory.i
+++ b/share/swig/3.0.12/octave/factory.i
diff --git a/share/swig/2.0.11/octave/implicit.i b/share/swig/3.0.12/octave/implicit.i
index 152c2b0..152c2b0 100644
--- a/share/swig/2.0.11/octave/implicit.i
+++ b/share/swig/3.0.12/octave/implicit.i
diff --git a/share/swig/2.0.11/octave/octave.swg b/share/swig/3.0.12/octave/octave.swg
index 872054d..872054d 100644
--- a/share/swig/2.0.11/octave/octave.swg
+++ b/share/swig/3.0.12/octave/octave.swg
diff --git a/share/swig/2.0.11/octave/octcomplex.swg b/share/swig/3.0.12/octave/octcomplex.swg
index a3e9ebf..a3e9ebf 100644
--- a/share/swig/2.0.11/octave/octcomplex.swg
+++ b/share/swig/3.0.12/octave/octcomplex.swg
diff --git a/share/swig/3.0.12/octave/octcontainer.swg b/share/swig/3.0.12/octave/octcontainer.swg
new file mode 100644
index 0000000..771edbd
--- /dev/null
+++ b/share/swig/3.0.12/octave/octcontainer.swg
@@ -0,0 +1,623 @@
+/* -----------------------------------------------------------------------------
+ * octcontainer.swg
+ *
+ * Octave cell <-> C++ container wrapper
+ *
+ * This wrapper, and its iterator, allows a general use (and reuse) of
+ * the mapping between C++ and Octave, thanks to the C++ templates.
+ *
+ * Of course, it needs the C++ compiler to support templates, but
+ * since we will use this wrapper with the STL containers, that should
+ * be the case.
+ * ----------------------------------------------------------------------------- */
+
+%{
+#include <climits>
+#include <iostream>
+%}
+
+
+#if !defined(SWIG_NO_EXPORT_ITERATOR_METHODS)
+# if !defined(SWIG_EXPORT_ITERATOR_METHODS)
+#  define SWIG_EXPORT_ITERATOR_METHODS SWIG_EXPORT_ITERATOR_METHODS
+# endif
+#endif
+
+%include <octiterators.swg>
+
+// The Octave C++ Wrap
+
+%fragment("<stdexcept>");
+
+%include <std_except.i>
+
+%fragment(SWIG_Traits_frag(octave_value),"header",fragment="StdTraits") {
+namespace swig {
+  template <>  struct traits<octave_value > {
+    typedef value_category category;
+    static const char* type_name() { return  "octave_value"; }
+  };
+  
+  template <>  struct traits_from<octave_value> {
+    typedef octave_value value_type;
+    static octave_value from(const value_type& val) {
+      return val;
+    }
+  };
+  
+  template <> 
+  struct traits_check<octave_value, value_category> {
+    static bool check(const octave_value&) {
+      return true;
+    }
+  };
+  
+  template <>  struct traits_asval<octave_value > {   
+    typedef octave_value value_type;
+    static int asval(const octave_value& obj, value_type *val) {
+      if (val) *val = obj;
+      return SWIG_OK;
+    }
+  };
+}
+}
+
+%fragment("OctSequence_Base","header",fragment="<stddef.h>")
+{
+%#include <functional>
+
+namespace std {
+  template <>
+  struct less <octave_value>
+  {
+    bool
+    operator()(const octave_value& v, const octave_value& w) const
+    { 
+      octave_value res = do_binary_op(octave_value::op_le,v,w);
+      return res.is_true();
+    }
+  };
+}
+
+namespace swig {
+  inline size_t
+  check_index(ptrdiff_t i, size_t size, bool insert = false) {
+    if ( i < 0 ) {
+      if ((size_t) (-i) <= size)
+	return (size_t) (i + size);
+    } else if ( (size_t) i < size ) {
+      return (size_t) i;
+    } else if (insert && ((size_t) i == size)) {
+      return size;
+    }
+    
+    throw std::out_of_range("index out of range");
+  }
+
+  inline size_t
+  slice_index(ptrdiff_t i, size_t size) {
+    if ( i < 0 ) {
+      if ((size_t) (-i) <= size) {
+	return (size_t) (i + size);
+      } else {
+	throw std::out_of_range("index out of range");
+      }
+    } else {
+      return ( (size_t) i < size ) ? ((size_t) i) : size;
+    }
+  }
+
+  template <class Sequence, class Difference>
+  inline typename Sequence::iterator
+  getpos(Sequence* self, Difference i)  {
+    typename Sequence::iterator pos = self->begin();
+    std::advance(pos, check_index(i,self->size()));
+    return pos;
+  }
+
+  template <class Sequence, class Difference>
+  inline typename Sequence::const_iterator
+  cgetpos(const Sequence* self, Difference i)  {
+    typename Sequence::const_iterator pos = self->begin();
+    std::advance(pos, check_index(i,self->size()));
+    return pos;
+  }
+
+  template <class Sequence, class Difference>
+  inline Sequence*
+  getslice(const Sequence* self, Difference i, Difference j) {
+    typename Sequence::size_type size = self->size();
+    typename Sequence::size_type ii = swig::check_index(i, size);
+    typename Sequence::size_type jj = swig::slice_index(j, size);
+
+    if (jj > ii) {
+      typename Sequence::const_iterator vb = self->begin();
+      typename Sequence::const_iterator ve = self->begin();
+      std::advance(vb,ii);
+      std::advance(ve,jj);
+      return new Sequence(vb, ve);
+    } else {
+      return new Sequence();
+    }
+  }
+
+  template <class Sequence, class Difference, class InputSeq>
+  inline void
+  setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) {
+    typename Sequence::size_type size = self->size();
+    typename Sequence::size_type ii = swig::check_index(i, size, true);
+    typename Sequence::size_type jj = swig::slice_index(j, size);
+    if (jj < ii) jj = ii;
+    size_t ssize = jj - ii;
+    if (ssize <= v.size()) {
+      typename Sequence::iterator sb = self->begin();
+      typename InputSeq::const_iterator vmid = v.begin();
+      std::advance(sb,ii);
+      std::advance(vmid, jj - ii);
+      self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
+    } else {
+      typename Sequence::iterator sb = self->begin();
+      typename Sequence::iterator se = self->begin();
+      std::advance(sb,ii);
+      std::advance(se,jj);
+      self->erase(sb,se);
+      self->insert(sb, v.begin(), v.end());
+    }
+  }
+
+  template <class Sequence, class Difference>
+  inline void
+  delslice(Sequence* self, Difference i, Difference j) {
+    typename Sequence::size_type size = self->size();
+    typename Sequence::size_type ii = swig::check_index(i, size, true);
+    typename Sequence::size_type jj = swig::slice_index(j, size);
+    if (jj > ii) {
+      typename Sequence::iterator sb = self->begin();
+      typename Sequence::iterator se = self->begin();
+      std::advance(sb,ii);
+      std::advance(se,jj);
+      self->erase(sb,se);
+    }
+  }
+}
+}
+
+%fragment("OctSequence_Cont","header",
+	  fragment="StdTraits",
+	  fragment="OctSequence_Base",
+	  fragment="OctSwigIterator_T")
+{
+namespace swig
+{
+  template <class T>
+    struct OctSequence_Ref // * octave can't support these, because of how assignment works
+  {
+    OctSequence_Ref(const octave_value& seq, int index)
+      : _seq(seq), _index(index)
+    {
+    }
+    
+    operator T () const
+    {
+      //      swig::SwigVar_PyObject item = OctSequence_GetItem(_seq, _index);
+      octave_value item; // * todo
+      try {
+	return swig::as<T>(item, true);
+      } catch (std::exception& e) {
+	char msg[1024];
+	sprintf(msg, "in sequence element %d ", _index);
+	if (!Octave_Error_Occurred()) {
+	  %type_error(swig::type_name<T>());
+	}
+	SWIG_Octave_AddErrorMsg(msg);
+	SWIG_Octave_AddErrorMsg(e.what());
+	throw;
+      }
+    }
+
+    OctSequence_Ref& operator=(const T& v)
+    {
+      //      OctSequence_SetItem(_seq, _index, swig::from<T>(v));
+      // * todo
+      return *this;
+    }
+
+  private:
+    octave_value _seq;
+    int _index;
+  };
+
+  template <class T>
+  struct OctSequence_ArrowProxy
+  {
+    OctSequence_ArrowProxy(const T& x): m_value(x) {}
+    const T* operator->() const { return &m_value; }
+    operator const T*() const { return &m_value; }
+    T m_value;
+  };
+
+  template <class T, class Reference >
+  struct OctSequence_InputIterator
+  {
+    typedef OctSequence_InputIterator<T, Reference > self;
+
+    typedef std::random_access_iterator_tag iterator_category;
+    typedef Reference reference;
+    typedef T value_type;
+    typedef T* pointer;
+    typedef int difference_type;
+
+    OctSequence_InputIterator()
+    {
+    }
+
+    OctSequence_InputIterator(const octave_value& seq, int index)
+      : _seq(seq), _index(index)
+    {
+    }
+
+    reference operator*() const
+    {
+      return reference(_seq, _index);
+    }
+
+    OctSequence_ArrowProxy<T>
+    operator->() const {
+      return OctSequence_ArrowProxy<T>(operator*());
+    }
+
+    bool operator==(const self& ri) const
+    {
+      return (_index == ri._index);
+    }
+
+    bool operator!=(const self& ri) const
+    {
+      return !(operator==(ri));
+    }
+
+    self& operator ++ ()
+    {
+      ++_index;
+      return *this;
+    }
+
+    self& operator -- ()
+    {
+      --_index;
+      return *this;
+    }
+
+    self& operator += (difference_type n)
+    {
+      _index += n;
+      return *this;
+    }
+
+    self operator +(difference_type n) const
+    {
+      return self(_seq, _index + n);
+    }
+
+    self& operator -= (difference_type n)
+    {
+      _index -= n;
+      return *this;
+    }
+
+    self operator -(difference_type n) const
+    {
+      return self(_seq, _index - n);
+    }
+
+    difference_type operator - (const self& ri) const
+    {
+      return _index - ri._index;
+    }
+
+    bool operator < (const self& ri) const
+    {
+      return _index < ri._index;
+    }
+
+    reference
+    operator[](difference_type n) const
+    {
+      return reference(_seq, _index + n);
+    }
+
+  private:
+    octave_value _seq;
+    difference_type _index;
+  };
+
+  template <class T>
+  struct OctSequence_Cont
+  {
+    typedef OctSequence_Ref<T> reference;
+    typedef const OctSequence_Ref<T> const_reference;
+    typedef T value_type;
+    typedef T* pointer;
+    typedef int difference_type;
+    typedef int size_type;
+    typedef const pointer const_pointer;
+    typedef OctSequence_InputIterator<T, reference> iterator;
+    typedef OctSequence_InputIterator<T, const_reference> const_iterator;
+
+    OctSequence_Cont(const octave_value& seq) : _seq(seq)
+    {
+      // * assert that we have map type etc.
+      /*
+      if (!OctSequence_Check(seq)) {
+	throw std::invalid_argument("a sequence is expected");
+      }
+      _seq = seq;
+      Py_INCREF(_seq);
+      */
+    }
+
+    ~OctSequence_Cont()
+    {
+    }
+
+    size_type size() const
+    {
+      //      return static_cast<size_type>(OctSequence_Size(_seq));
+      return 0; // * todo
+    }
+
+    bool empty() const
+    {
+      return size() == 0;
+    }
+
+    iterator begin()
+    {
+      return iterator(_seq, 0);
+    }
+
+    const_iterator begin() const
+    {
+      return const_iterator(_seq, 0);
+    }
+
+    iterator end()
+    {
+      return iterator(_seq, size());
+    }
+
+    const_iterator end() const
+    {
+      return const_iterator(_seq, size());
+    }
+
+    reference operator[](difference_type n)
+    {
+      return reference(_seq, n);
+    }
+
+    const_reference operator[](difference_type n)  const
+    {
+      return const_reference(_seq, n);
+    }
+
+    bool check(bool set_err = true) const
+    {
+      int s = size();
+      for (int i = 0; i < s; ++i) {
+	//	swig::SwigVar_PyObject item = OctSequence_GetItem(_seq, i);
+	octave_value item; // * todo
+	if (!swig::check<value_type>(item)) {
+	  if (set_err) {
+	    char msg[1024];
+	    sprintf(msg, "in sequence element %d", i);
+	    SWIG_Error(SWIG_RuntimeError, msg);
+	  }
+	  return false;
+	}
+      }
+      return true;
+    }
+
+  private:
+    octave_value _seq;
+  };
+
+}
+}
+
+%define %swig_sequence_iterator(Sequence...)
+#if defined(SWIG_EXPORT_ITERATOR_METHODS)
+  class iterator;
+  class reverse_iterator;
+  class const_iterator;
+  class const_reverse_iterator;
+
+  %typemap(out,noblock=1,fragment="OctSequence_Cont")
+    iterator, reverse_iterator, const_iterator, const_reverse_iterator {
+    $result = SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &)),
+				 swig::OctSwigIterator::descriptor(),SWIG_POINTER_OWN);
+  }
+  %typemap(out,fragment="OctSequence_Cont")
+    std::pair<iterator, iterator>, std::pair<const_iterator, const_iterator> {
+    octave_value_list tmpc;
+    tmpc.append(SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &).first),
+				   swig::OctSwigIterator::descriptor(),SWIG_POINTER_OWN));
+    tmpc.append(SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &).second),
+				   swig::OctSwigIterator::descriptor(),SWIG_POINTER_OWN));
+    $result = Cell(tmpc);
+  }
+
+  %fragment("SwigPyPairBoolOutputIterator","header",fragment=SWIG_From_frag(bool),fragment="OctSequence_Cont") {}
+
+  %typemap(out,fragment="OctPairBoolOutputIterator")
+    std::pair<iterator, bool>, std::pair<const_iterator, bool> {
+    octave_value_list tmpc;
+    tmpc.append(SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &).first),
+				   swig::OctSwigIterator::descriptor(),SWIG_POINTER_OWN));
+    tmpc.append(SWIG_From(bool)(%static_cast($1,const $type &).second));
+    $result = Cell(tmpc);
+  }
+
+  %typemap(in,noblock=1,fragment="OctSequence_Cont")
+    iterator(swig::OctSwigIterator *iter = 0, int res),
+    reverse_iterator(swig::OctSwigIterator *iter = 0, int res),
+    const_iterator(swig::OctSwigIterator *iter = 0, int res),
+    const_reverse_iterator(swig::OctSwigIterator *iter = 0, int res) {
+    res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter), swig::OctSwigIterator::descriptor(), 0);
+    if (!SWIG_IsOK(res) || !iter) {
+      %argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
+    } else {
+      swig::OctSwigIterator_T<$type > *iter_t = dynamic_cast<swig::OctSwigIterator_T<$type > *>(iter);
+      if (iter_t) {
+	$1 = iter_t->get_current();
+      } else {
+	%argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
+      }
+    }
+  }
+
+  %typecheck(%checkcode(ITERATOR),noblock=1,fragment="OctSequence_Cont")
+    iterator, reverse_iterator, const_iterator, const_reverse_iterator {
+    swig::OctSwigIterator *iter = 0;
+    int res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter), swig::OctSwigIterator::descriptor(), 0);
+    $1 = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::OctSwigIterator_T<$type > *>(iter) != 0));
+  }
+
+  %fragment("OctSequence_Cont");
+#endif //SWIG_EXPORT_ITERATOR_METHODS
+%enddef
+
+// The octave container methods
+
+%define %swig_container_methods(Container...)
+%enddef
+
+%define %swig_sequence_methods_common(Sequence...)
+  %swig_sequence_iterator(%arg(Sequence))
+  %swig_container_methods(%arg(Sequence))
+  
+  %fragment("OctSequence_Base");
+
+  %extend {
+    value_type pop() throw (std::out_of_range) {
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      Sequence::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
+
+    value_type __paren__(difference_type i) throw (std::out_of_range) {
+      return *(swig::cgetpos(self, i));
+    }
+
+    void __paren_asgn__(difference_type i, value_type x) throw (std::out_of_range) {
+      *(swig::getpos(self,i)) = x;
+    }
+
+    void append(value_type x) {
+      self->push_back(x);
+    }
+  }
+
+%enddef
+
+%define %swig_sequence_methods(Sequence...)
+  %swig_sequence_methods_common(%arg(Sequence))
+%enddef
+
+%define %swig_sequence_methods_val(Sequence...)
+  %swig_sequence_methods_common(%arg(Sequence))
+%enddef
+
+//
+// Common fragments
+//
+
+%fragment("StdSequenceTraits","header",
+	  fragment="StdTraits",
+	  fragment="OctSequence_Cont")
+{
+namespace swig {
+  template <class OctSeq, class Seq>
+  inline void
+  assign(const OctSeq& octseq, Seq* seq) {
+%#ifdef SWIG_STD_NOASSIGN_STL
+    typedef typename OctSeq::value_type value_type;
+    typename OctSeq::const_iterator it = octseq.begin();
+    for (;it != octseq.end(); ++it) {
+      seq->insert(seq->end(),(value_type)(*it));
+    }
+%#else
+    seq->assign(octseq.begin(), octseq.end());
+%#endif
+  }
+
+  template <class Seq, class T = typename Seq::value_type >
+  struct traits_asptr_stdseq {
+    typedef Seq sequence;
+    typedef T value_type;
+
+    static int asptr(const octave_value& obj, sequence **seq) {
+      if (!obj.is_defined() || Swig::swig_value_deref(obj)) {
+	sequence *p;
+	swig_type_info *descriptor = swig::type_info<sequence>();
+	if (descriptor && SWIG_IsOK(SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0))) {
+	  if (seq) *seq = p;
+	  return SWIG_OLDOBJ;
+	}
+      } else if (obj.is_cell()) {
+	try {
+	  OctSequence_Cont<value_type> octseq(obj);
+	  if (seq) {
+	    sequence *pseq = new sequence();
+	    assign(octseq, pseq);
+	    *seq = pseq;
+	    return SWIG_NEWOBJ;
+	  } else {
+	    return octseq.check() ? SWIG_OK : SWIG_ERROR;
+	  }
+	} catch (std::exception& e) {
+	  if (seq&&!error_state)
+	    error("swig type error: %s",e.what());
+	  return SWIG_ERROR;
+	}
+      }
+      return SWIG_ERROR;
+    }
+  };
+
+  template <class Seq, class T = typename Seq::value_type >
+  struct traits_from_stdseq {
+    typedef Seq sequence;
+    typedef T value_type;
+    typedef typename Seq::size_type size_type;
+    typedef typename sequence::const_iterator const_iterator;
+
+    static octave_value from(const sequence& seq) {
+#ifdef SWIG_OCTAVE_EXTRA_NATIVE_CONTAINERS
+      swig_type_info *desc = swig::type_info<sequence>();
+      if (desc && desc->clientdata) {
+	return SWIG_NewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
+      }
+#endif
+      size_type size = seq.size();
+      if (size <= (size_type)INT_MAX) {
+	Cell c(size,1);
+	int i = 0;
+	for (const_iterator it = seq.begin();
+	     it != seq.end(); ++it, ++i) {
+	  c(i) = swig::from<value_type>(*it);
+	}
+	return c;
+      } else {
+	error("swig overflow error: sequence size not valid in octave");
+	return octave_value();
+      }
+      return octave_value();
+    }
+  };
+}
+}
+
diff --git a/share/swig/2.0.11/octave/octfragments.swg b/share/swig/3.0.12/octave/octfragments.swg
index 8b13789..8b13789 100644
--- a/share/swig/2.0.11/octave/octfragments.swg
+++ b/share/swig/3.0.12/octave/octfragments.swg
diff --git a/share/swig/2.0.11/octave/octiterators.swg b/share/swig/3.0.12/octave/octiterators.swg
index 79a20f8..79a20f8 100644
--- a/share/swig/2.0.11/octave/octiterators.swg
+++ b/share/swig/3.0.12/octave/octiterators.swg
diff --git a/share/swig/3.0.12/octave/octopers.swg b/share/swig/3.0.12/octave/octopers.swg
new file mode 100644
index 0000000..665b703
--- /dev/null
+++ b/share/swig/3.0.12/octave/octopers.swg
@@ -0,0 +1,86 @@
+/* ------------------------------------------------------------
+ * Overloaded operator support
+ * ------------------------------------------------------------ */
+
+#ifdef __cplusplus
+
+// operators supported in Octave, and the methods they are routed to
+
+// __brace__      a{args}
+// __brace_asgn__ a{args} = rhs
+// __paren__      a(args)
+// __paren_asgn__ a(args) = rhs
+// __str__        generates string rep
+
+// __not__        !a
+// __uplus__      +a
+// __uminus__     -a
+// __transpose__  a.'
+// __hermitian__  a'
+// __incr__       a++
+// __decr__       a--
+// __add__        a + b
+// __sub__        a - b
+// __mul__        a * b
+// __div__        a / b
+// __pow__        a ^ b
+// __ldiv__       a \ b
+// __lt__         a < b
+// __le__         a <= b
+// __eq__         a == b
+// __ge__         a >= b
+// __gt__         a > b
+// __ne__         a != b
+// __el_mul__     a .* b
+// __el_div__     a ./ b
+// __el_pow__     a .^ b
+// __el_ldiv__    a .\ b
+// __el_and__     a & b
+// __el_or__      a | b
+
+// operators supported in C++, and the methods that route to them
+
+%rename(__add__)       *::operator+;
+%rename(__add__)       *::operator+();
+%rename(__add__)       *::operator+() const;
+%rename(__sub__)       *::operator-;
+%rename(__uminus__)    *::operator-();
+%rename(__uminus__)    *::operator-() const;
+%rename(__mul__)       *::operator*;
+%rename(__div__)       *::operator/;
+%rename(__mod__)       *::operator%;
+%rename(__el_and__)    *::operator&&;
+%rename(__el_or__)     *::operator||;
+%rename(__xor__)       *::operator^;
+%rename(__invert__)    *::operator~;
+%rename(__lt__)        *::operator<;
+%rename(__le__)        *::operator<=;
+%rename(__gt__)        *::operator>;
+%rename(__ge__)        *::operator>=;
+%rename(__eq__)        *::operator==;
+%rename(__ne__)        *::operator!=;
+%rename(__not__)       *::operator!;
+%rename(__incr__)      *::operator++;
+%rename(__decr__)      *::operator--;
+%rename(__paren__)     *::operator();
+%rename(__brace__)     *::operator[];
+
+// Ignored inplace operators
+%ignoreoperator(PLUSEQ)     operator+=;
+%ignoreoperator(MINUSEQ)    operator-=;
+%ignoreoperator(MULEQ)      operator*=;
+%ignoreoperator(DIVEQ)      operator/=;
+%ignoreoperator(MODEQ)      operator%=;
+%ignoreoperator(LSHIFTEQ)   operator<<=;
+%ignoreoperator(RSHIFTEQ)   operator>>=;
+%ignoreoperator(ANDEQ)      operator&=;
+%ignoreoperator(OREQ)       operator|=;
+%ignoreoperator(XOREQ)      operator^=;
+
+// Ignored operators
+%ignoreoperator(EQ)         operator=;
+%ignoreoperator(ARROWSTAR)  operator->*;
+%ignoreoperator(LSHIFT)     operator<<;
+%ignoreoperator(RSHIFT)     operator>>;
+
+#endif /* __cplusplus */
diff --git a/share/swig/3.0.12/octave/octprimtypes.swg b/share/swig/3.0.12/octave/octprimtypes.swg
new file mode 100644
index 0000000..663d1fe
--- /dev/null
+++ b/share/swig/3.0.12/octave/octprimtypes.swg
@@ -0,0 +1,244 @@
+/* ------------------------------------------------------------
+ * Primitive Types
+ * ------------------------------------------------------------ */
+
+
+// boolean
+
+%fragment(SWIG_From_frag(bool),"header") {
+SWIGINTERNINLINE octave_value
+  SWIG_From_dec(bool)(bool value)
+{
+  return octave_value(value);
+}
+}
+
+%fragment(SWIG_AsVal_frag(bool),"header",
+	  fragment=SWIG_AsVal_frag(long)) {
+SWIGINTERN int
+SWIG_AsVal_dec(bool)(const octave_value& ov, bool *val)
+{
+  if (!ov.is_bool_type())
+    return SWIG_ERROR;
+  if (val)
+    *val = ov.bool_value();
+  return SWIG_OK;
+}
+}
+
+// long
+
+%fragment(SWIG_From_frag(long),"header") {
+  SWIGINTERNINLINE octave_value SWIG_From_dec(long)  (long value)
+    {    
+      return octave_value(value);
+    }
+}
+
+
+%fragment(SWIG_AsVal_frag(long),"header") {
+  SWIGINTERN int SWIG_AsVal_dec(long)(const octave_value& ov, long* val)
+    {
+      if (!ov.is_scalar_type())
+	return SWIG_TypeError;
+      if (ov.is_complex_scalar())
+	return SWIG_TypeError;
+      if (ov.is_double_type()||ov.is_single_type()) {
+	double v=ov.double_value();
+	if (v!=floor(v))
+	  return SWIG_TypeError;
+      }
+      if (val)
+	*val = ov.long_value();
+      return SWIG_OK;
+    }
+}
+
+// unsigned long
+
+%fragment(SWIG_From_frag(unsigned long),"header") {
+  SWIGINTERNINLINE octave_value SWIG_From_dec(unsigned long)  (unsigned long value)
+    {    
+      return octave_value(value);
+    }
+}
+
+
+%fragment(SWIG_AsVal_frag(unsigned long),"header") {
+  SWIGINTERN int SWIG_AsVal_dec(unsigned long)(const octave_value& ov, unsigned long* val)
+    {
+      if (!ov.is_scalar_type())
+	return SWIG_TypeError;
+      if (ov.is_complex_scalar())
+	return SWIG_TypeError;
+      if (ov.is_double_type()||ov.is_single_type()) {
+	double v=ov.double_value();
+	if (v<0)
+	  return SWIG_OverflowError;  
+	if (v!=floor(v))
+	  return SWIG_TypeError;
+      }
+      if (ov.is_int8_type()||ov.is_int16_type()||
+	  ov.is_int32_type()) {
+	long v=ov.long_value();
+	if (v<0)
+	  return SWIG_OverflowError;  
+      }
+      if (ov.is_int64_type()) {
+	long long v=ov.int64_scalar_value().value();
+	if (v<0)
+	  return SWIG_OverflowError;  
+      }
+      if (val)
+	*val = ov.ulong_value();
+      return SWIG_OK;
+    }
+}
+
+// long long
+
+%fragment(SWIG_From_frag(long long),"header",
+	  fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+  SWIGINTERNINLINE octave_value SWIG_From_dec(long long)  (long long value)
+    {    
+      return octave_int64(value);
+    }
+%#endif
+}
+
+
+%fragment(SWIG_AsVal_frag(long long),"header",
+	  fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+  SWIGINTERN int SWIG_AsVal_dec(long long)(const octave_value& ov, long long* val)
+    {
+      if (!ov.is_scalar_type())
+	return SWIG_TypeError;
+      if (ov.is_complex_scalar())
+	return SWIG_TypeError;
+      if (ov.is_double_type()||ov.is_single_type()) {
+	double v=ov.double_value();
+	if (v!=floor(v))
+	  return SWIG_TypeError;
+      }
+      if (val) {
+	if (ov.is_int64_type())
+	  *val = ov.int64_scalar_value().value();
+	else if (ov.is_uint64_type())
+	  *val = ov.uint64_scalar_value().value();
+	else
+	  *val = ov.long_value();
+      }
+      return SWIG_OK;
+    }
+%#endif
+}
+
+%fragment(SWIG_From_frag(unsigned long long),"header",
+	  fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+  SWIGINTERNINLINE octave_value SWIG_From_dec(unsigned long long)  (unsigned long long value)
+    {    
+      return octave_uint64(value);
+    }
+%#endif
+}
+
+%fragment(SWIG_AsVal_frag(unsigned long long),"header",
+	  fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+  SWIGINTERN int SWIG_AsVal_dec(unsigned long long)(const octave_value& ov, unsigned long long* val)
+    {
+      if (!ov.is_scalar_type())
+	return SWIG_TypeError;
+      if (ov.is_complex_scalar())
+	return SWIG_TypeError;
+      if (ov.is_double_type()||ov.is_single_type()) {
+	double v=ov.double_value();
+	if (v<0)
+	  return SWIG_OverflowError;  
+	if (v!=floor(v))
+	  return SWIG_TypeError;
+      }
+      if (ov.is_int8_type()||ov.is_int16_type()||
+	  ov.is_int32_type()) {
+	long v=ov.long_value();
+	if (v<0)
+	  return SWIG_OverflowError;  
+      }
+      if (ov.is_int64_type()) {
+	long long v=ov.int64_scalar_value().value();
+	if (v<0)
+	  return SWIG_OverflowError;  
+      }
+      if (val) {
+	if (ov.is_int64_type())
+	  *val = ov.int64_scalar_value().value();
+	else if (ov.is_uint64_type())
+	  *val = ov.uint64_scalar_value().value();
+	else
+	  *val = ov.long_value();
+      }
+      return SWIG_OK;
+    }
+%#endif
+}
+
+// double
+
+%fragment(SWIG_From_frag(double),"header") {
+  SWIGINTERNINLINE octave_value SWIG_From_dec(double)  (double value)
+    {    
+      return octave_value(value);
+    }
+}
+
+
+%fragment(SWIG_AsVal_frag(double),"header") {
+  SWIGINTERN int SWIG_AsVal_dec(double)(const octave_value& ov, double* val)
+    {
+      if (!ov.is_scalar_type())
+	return SWIG_TypeError;
+      if (ov.is_complex_scalar())
+	return SWIG_TypeError;
+      if (val)
+	*val = ov.double_value();
+      return SWIG_OK;
+    }
+}
+
+// const char* (strings)
+
+%fragment("SWIG_AsCharPtrAndSize","header") {
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(octave_value ov, char** cptr, size_t* psize, int *alloc)
+{
+  if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
+    ov = ov.cell_value()(0);
+  if (!ov.is_string())
+    return SWIG_TypeError;
+  
+  std::string str=ov.string_value();
+  size_t len=str.size();
+  char* cstr=(char*)str.c_str();
+  if (alloc) {
+    *cptr = %new_copy_array(cstr, len + 1, char);
+    *alloc = SWIG_NEWOBJ;
+  } else if (cptr)
+    *cptr = cstr;
+  if (psize)
+    *psize = len + 1;
+  return SWIG_OK;
+}
+}
+
+%fragment("SWIG_FromCharPtrAndSize","header",fragment="SWIG_pchar_descriptor") {
+SWIGINTERNINLINE octave_value
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+  return std::string(carray,carray+size);
+}
+}
+
+
diff --git a/share/swig/3.0.12/octave/octrun.swg b/share/swig/3.0.12/octave/octrun.swg
new file mode 100644
index 0000000..57a888f
--- /dev/null
+++ b/share/swig/3.0.12/octave/octrun.swg
@@ -0,0 +1,1426 @@
+#if !SWIG_OCTAVE_PREREQ(3,2,0)
+#define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
+#else
+#define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
+#endif
+
+SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs) {
+  if (num_args > max_args && !varargs)
+    error("function %s takes at most %i arguments", func_name, max_args);
+  else if (num_args < min_args)
+    error("function %s requires at least %i arguments", func_name, min_args);
+  else
+    return true;
+  return false;
+}
+
+SWIGRUNTIME octave_value_list *SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov) {
+  ovl->append(ov);
+  return ovl;
+}
+
+SWIGRUNTIME octave_value SWIG_ErrorType(int code) {
+  switch (code) {
+  case SWIG_MemoryError:
+    return "SWIG_MemoryError";
+  case SWIG_IOError:
+    return "SWIG_IOError";
+  case SWIG_RuntimeError:
+    return "SWIG_RuntimeError";
+  case SWIG_IndexError:
+    return "SWIG_IndexError";
+  case SWIG_TypeError:
+    return "SWIG_TypeError";
+  case SWIG_DivisionByZero:
+    return "SWIG_DivisionByZero";
+  case SWIG_OverflowError:
+    return "SWIG_OverflowError";
+  case SWIG_SyntaxError:
+    return "SWIG_SyntaxError";
+  case SWIG_ValueError:
+    return "SWIG_ValueError";
+  case SWIG_SystemError:
+    return "SWIG_SystemError";
+  case SWIG_AttributeError:
+    return "SWIG_AttributeError";
+  }
+  return "SWIG unknown error";
+}
+
+SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg) {
+  octave_value type(SWIG_ErrorType(code));
+  std::string r = msg;
+  r += " (" + type.string_value() + ")";
+  error(r.c_str());
+  return octave_value(r);
+}
+
+#define SWIG_fail                                       goto fail
+
+#define SWIG_Octave_ConvertPtr(obj, pptr, type, flags)  SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Octave_NewPointerObj(ptr, type, flags)
+#define swig_owntype                                    int
+
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Octave_NewPackedObj(ptr, sz, type)
+
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Octave_NewPackedObj(ptr, sz, type)
+
+#define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
+#define SWIG_MODULE_CLIENTDATA_TYPE void*
+
+#define Octave_Error_Occurred() 0
+#define SWIG_Octave_AddErrorMsg(msg) {;}
+
+SWIGRUNTIME swig_module_info *SWIG_Octave_GetModule(void *clientdata);
+SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer);
+
+// For backward compatibility only
+#define SWIG_POINTER_EXCEPTION  0
+#define SWIG_arg_fail(arg)      0
+
+// Runtime API implementation
+
+#include <map>
+#include <vector>
+#include <string>
+
+typedef octave_value_list(*octave_func) (const octave_value_list &, int);
+class octave_swig_type;
+
+namespace Swig {
+
+#ifdef SWIG_DIRECTORS
+
+  class Director;
+
+  typedef std::map < void *, Director * > rtdir_map;
+  SWIGINTERN rtdir_map* get_rtdir_map();
+  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *d);
+  SWIGINTERNINLINE void erase_rtdir(void *vptr);
+  SWIGINTERNINLINE Director *get_rtdir(void *vptr);
+
+  SWIGRUNTIME void swig_director_destroyed(octave_swig_type *self, Director *d);
+  SWIGRUNTIME octave_swig_type *swig_director_get_self(Director *d);
+  SWIGRUNTIME void swig_director_set_self(Director *d, octave_swig_type *self);
+
+#endif
+
+  SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost);
+  SWIGRUNTIME octave_swig_type *swig_value_deref(octave_value ov);
+  SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov);
+}
+
+#ifdef SWIG_DIRECTORS
+SWIGRUNTIME void swig_acquire_ownership(void *vptr);
+SWIGRUNTIME void swig_acquire_ownership_array(void *vptr);
+SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
+#endif
+
+  struct swig_octave_member {
+    const char *name;
+    octave_func method;
+    octave_func get_method;
+    octave_func set_method;
+    int flags;			// 1 static, 2 global
+    const char *doc;
+    bool is_static() const {
+      return flags &1;
+    } bool is_global() const {
+      return flags &2;
+    }
+  };
+
+  struct swig_octave_class {
+    const char *name;
+    swig_type_info **type;
+    int director;
+    octave_func constructor;
+    const char *constructor_doc;
+    octave_func destructor;
+    const swig_octave_member *members;
+    const char **base_names;
+    const swig_type_info **base;
+  };
+
+  // octave_swig_type plays the role of both the shadow class and the class 
+  // representation within Octave, since there is no support for classes.
+  //
+  // These should really be decoupled, with the class support added to Octave
+  // and the shadow class given by an m-file script. That would dramatically 
+  // reduce the runtime complexity, and be more in line w/ other modules.
+
+  class octave_swig_type:public octave_base_value {
+    struct cpp_ptr {
+      void *ptr;
+      bool destroyed;
+      cpp_ptr(void *_ptr):ptr(_ptr), destroyed(false) {
+      }};
+    typedef std::pair < const swig_type_info *, cpp_ptr > type_ptr_pair;
+
+    mutable swig_module_info *module;
+
+    const swig_type_info *construct_type;	// type of special type object
+    std::vector < type_ptr_pair > types;	// our c++ base classes
+    int own;			// whether we call c++ destructors when we die
+
+    typedef std::pair < const swig_octave_member *, octave_value > member_value_pair;
+    typedef std::map < std::string, member_value_pair > member_map;
+    member_map members;
+    bool always_static;
+
+    const swig_octave_member *find_member(const swig_type_info *type, const std::string &name) {
+      if (!type->clientdata)
+	return 0;
+      swig_octave_class *c = (swig_octave_class *) type->clientdata;
+      const swig_octave_member *m;
+      for (m = c->members; m->name; ++m)
+	if (m->name == name)
+	  return m;
+      for (int j = 0; c->base_names[j]; ++j) {
+	if (!c->base[j]) {
+	  if (!module)
+	    module = SWIG_GetModule(0);
+	  assert(module);
+	  c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
+	}
+	if (!c->base[j])
+	  return 0;
+	if ((m = find_member(c->base[j], name)))
+	  return m;
+      }
+      return 0;
+    }
+
+    member_value_pair *find_member(const std::string &name, bool insert_if_not_found) {
+      member_map::iterator it = members.find(name);
+      if (it != members.end())
+	return &it->second;
+      const swig_octave_member *m;
+      for (unsigned int j = 0; j < types.size(); ++j)
+	if ((m = find_member(types[j].first, name)))
+	  return &members.insert(std::make_pair(name, std::make_pair(m, octave_value()))).first->second;
+      if (!insert_if_not_found)
+	return 0;
+      return &members[name];
+    }
+
+    const swig_type_info *find_base(const std::string &name, const swig_type_info *base) {
+      if (!base) {
+	for (unsigned int j = 0; j < types.size(); ++j) {
+	  assert(types[j].first->clientdata);
+	  swig_octave_class *cj = (swig_octave_class *) types[j].first->clientdata;
+	  if (cj->name == name)
+	    return types[j].first;
+	}
+	return 0;
+      }
+      assert(base->clientdata);
+      swig_octave_class *c = (swig_octave_class *) base->clientdata;
+      for (int j = 0; c->base_names[j]; ++j) {
+	if (!c->base[j]) {
+	  if (!module)
+	    module = SWIG_GetModule(0);
+	  assert(module);
+	  c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
+	}
+	if (!c->base[j])
+	  return 0;
+	assert(c->base[j]->clientdata);
+	swig_octave_class *cj = (swig_octave_class *) c->base[j]->clientdata;
+	if (cj->name == name)
+	  return c->base[j];
+      }
+      return 0;
+    }
+
+    void load_members(const swig_octave_class* c,member_map& out) const {
+      for (const swig_octave_member *m = c->members; m->name; ++m) {
+	if (out.find(m->name) == out.end())
+	  out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
+      }
+      for (int j = 0; c->base_names[j]; ++j) {
+	if (!c->base[j]) {
+	  if (!module)
+	    module = SWIG_GetModule(0);
+	  assert(module);
+	  c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
+	}
+	if (!c->base[j])
+	  continue;
+	assert(c->base[j]->clientdata);
+	const swig_octave_class *cj =
+	  (const swig_octave_class *) c->base[j]->clientdata;
+	load_members(cj,out);
+      }
+    }
+
+    void load_members(member_map& out) const {
+      out=members;
+      for (unsigned int j = 0; j < types.size(); ++j)
+	if (types[j].first->clientdata)
+	  load_members((const swig_octave_class *) types[j].first->clientdata, out);
+    }
+
+    octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout) {
+      if (m->second.is_defined())
+	return m->second.subsref("(", std::list < octave_value_list > (1, args), nargout);
+      else if (m->first && m->first->method)
+	return m->first->method(args, nargout);
+      error("member not defined or not invocable");
+      return octave_value_list();
+    }
+
+    bool dispatch_unary_op(const std::string &symbol, octave_value &ret) const {
+      octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
+      member_value_pair *m = nc_this->find_member(symbol, false);
+      if (!m || m->first->is_static() || m->first->is_global())
+	return false;
+      octave_value_list args;
+      args.append(nc_this->as_value());
+      octave_value_list argout(nc_this->member_invoke(m, args, 1));
+      if (argout.length() < 1)
+	return false;
+      ret = argout(0);
+      return true;
+    }
+
+    bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) const {
+      octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
+      member_value_pair *m = nc_this->find_member(symbol, false);
+      if (!m || m->first->is_static() || m->first->is_global())
+	return false;
+      octave_value_list args;
+      args.append(nc_this->as_value());
+      args.append(make_value_hack(rhs));
+      octave_value_list argout(nc_this->member_invoke(m, args, 1));
+      if (argout.length() < 1)
+	return false;
+      ret = argout(0);
+      return true;
+    }
+
+    bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) const {
+      octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
+      member_value_pair *m = nc_this->find_member(symbol, false);
+      if (!m || m->first->is_static() || m->first->is_global())
+	return false;
+      octave_value_list args;
+      args.append(nc_this->as_value());
+      args.append(rhs);
+      octave_value_list argout(nc_this->member_invoke(m, args, 1));
+      if (argout.length() >= 1)
+	ret = argout(0);
+      return true;
+    }
+
+    octave_value_list member_deref(member_value_pair *m, const octave_value_list &args) {
+      if (m->second.is_defined())
+	return m->second;
+      else if (m->first) {
+	if (m->first->get_method)
+	  return m->first->get_method(args, 1);
+	else if (m->first->method)
+	  return octave_value(new octave_builtin(m->first->method));
+      }
+      error("undefined member");
+      return octave_value_list();
+    }
+
+    static octave_value make_value_hack(const octave_base_value &x) {
+      ((octave_swig_type &) x).count++;
+      return octave_value((octave_base_value *) &x);
+    }
+
+    octave_swig_type(const octave_swig_type &x);
+    octave_swig_type &operator=(const octave_swig_type &rhs);
+  public:
+
+    octave_swig_type(void *_ptr = 0, const swig_type_info *_type = 0, int _own = 0,
+		     bool _always_static = false)
+      :	module(0), construct_type(_ptr ? 0 : _type), own(_own), 
+      always_static(_always_static) {
+      if (_type || _ptr)
+	types.push_back(std::make_pair(_type, _ptr));
+#ifdef SWIG_DIRECTORS
+      if (_ptr) {
+	Swig::Director *d = Swig::get_rtdir(_ptr);
+	if (d)
+	  Swig::swig_director_set_self(d, this);
+      }
+#endif
+    }
+
+    ~octave_swig_type() {
+      if (own) {
+	++count;
+	for (unsigned int j = 0; j < types.size(); ++j) {
+	  if (!types[j].first || !types[j].first->clientdata)
+	    continue;
+	  swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
+	  if (c->destructor && !types[j].second.destroyed && types[j].second.ptr) {
+	    c->destructor(as_value(), 0);
+	  }
+	}
+      }
+#ifdef SWIG_DIRECTORS
+      for (unsigned int j = 0; j < types.size(); ++j)
+	Swig::erase_rtdir(types[j].second.ptr);
+#endif
+    }
+
+    dim_vector dims(void) const {
+      octave_value out;
+      if (!dispatch_unary_op("__dims__", out))
+        return dim_vector(1,1);
+
+      // Return value should be cell or matrix of integers
+      if (out.is_cell()) {
+        const Cell & c=out.cell_value();
+        int ndim = c.rows();
+        if (ndim==1 && c.columns()!=1) ndim = c.columns();
+
+        dim_vector d;
+        d.resize(ndim < 2 ? 2 : ndim);
+        d(0) = d(1) = 1;
+
+        // Fill in dim_vector 
+        for (int k=0;k<ndim;k++) {
+          const octave_value& obj = c(k);
+          d.elem(k) = obj.int_value();
+          
+          // __dims__ should return a cell filled with integers
+          if (error_state) return dim_vector(1,1);
+        }
+        return d;
+      } else if (out.is_matrix_type() || out.is_numeric_type() ) {
+        if (out.rows()==1 || out.columns()==1) {
+           Array<int> a = out.int_vector_value();
+           if (error_state) return dim_vector(1,1);
+           dim_vector d;
+           d.resize(a.numel() < 2 ? 2 : a.numel());
+           d(0) = d(1) = 1;
+           for (int k=0;k<a.numel();k++) {
+              d.elem(k) = a(k);
+           }
+           return d;
+        } else {
+          return dim_vector(1,1);
+        }
+      } else {
+        return dim_vector(1,1);
+      }
+    }
+
+    octave_value as_value() {
+      ++count;
+      return Swig::swig_value_ref(this);
+    }
+
+    void incref() {
+      ++count;
+    }
+
+    void decref() {
+      if (!--count)
+	delete this;
+    }
+
+    long swig_this() const {
+      if (!types.size())
+	return (long) this;
+      return (long) types[0].second.ptr;
+    }
+    const char* help_text() const {
+      if (!types.size())
+	return 0;
+      if (!types[0].first->clientdata)
+	return 0;
+      swig_octave_class *c = (swig_octave_class *) types[0].first->clientdata;
+      return c->constructor_doc;
+    }
+
+    std::string swig_type_name() const {
+      // * need some way to manually name subclasses.
+      // * eg optional first arg to subclass(), or named_subclass()
+      std::string ret;
+      for (unsigned int j = 0; j < types.size(); ++j) {
+	if (j)
+	  ret += "_";
+	if (types[j].first->clientdata) {
+	  swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
+	  ret += c->name;
+	} else
+	  ret += types[j].first->name;
+      }
+      return ret;
+    }
+
+    void merge(octave_swig_type &rhs) {
+      rhs.own = 0;
+      for (unsigned int j = 0; j < rhs.types.size(); ++j) {
+	assert(!rhs.types[j].second.destroyed);
+#ifdef SWIG_DIRECTORS
+	Swig::Director *d = Swig::get_rtdir(rhs.types[j].second.ptr);
+	if (d)
+	  Swig::swig_director_set_self(d, this);
+#endif
+      }
+      types.insert(types.end(), rhs.types.begin(), rhs.types.end());
+      members.insert(rhs.members.begin(), rhs.members.end());
+      rhs.types.clear();
+      rhs.members.clear();
+    }
+
+    typedef member_map::const_iterator swig_member_const_iterator;
+    swig_member_const_iterator swig_members_begin() { return members.begin(); }
+    swig_member_const_iterator swig_members_end() { return members.end(); }
+
+    int cast(void **vptr, swig_type_info *type, int *_own, int flags) {
+      int res = SWIG_ERROR;
+      if (_own)
+	*_own = own;
+      if (flags &SWIG_POINTER_DISOWN)
+	own = 0;
+      if (!type && types.size()) {
+	if(vptr)
+          *vptr = types[0].second.ptr;
+        return SWIG_OK;
+      }
+      for (unsigned int j = 0; j < types.size(); ++j)
+	if (type == types[j].first) {
+	  if(vptr)
+            *vptr = types[j].second.ptr;
+          return SWIG_OK;
+        }
+      for (unsigned int j = 0; j < types.size(); ++j) {
+	swig_cast_info *tc = SWIG_TypeCheck(types[j].first->name, type);
+	if (!tc)
+	  continue;
+        if(vptr) {
+	  int newmemory = 0;
+	  *vptr = SWIG_TypeCast(tc, types[j].second.ptr, &newmemory);
+	    if (newmemory == SWIG_CAST_NEW_MEMORY) {
+              assert(_own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+              if (_own)
+                *_own = *_own | SWIG_CAST_NEW_MEMORY;
+            }
+        }
+        res = SWIG_OK;
+        break;
+      }
+      return res;
+    }
+
+    bool is_owned() const {
+      return own;
+    }
+
+#ifdef SWIG_DIRECTORS
+    void director_destroyed(Swig::Director *d) {
+      bool found = false;
+      for (unsigned int j = 0; j < types.size(); ++j) {
+	Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
+	if (dj == d) {
+	  types[j].second.destroyed = true;
+	  found = true;
+	}
+      }
+      assert(found);
+    }
+#endif
+
+    void assign(const std::string &name, const octave_value &ov) {
+      members[name] = std::make_pair((const swig_octave_member *) 0, ov);
+    }
+
+    void assign(const std::string &name, const swig_octave_member *m) {
+      members[name] = std::make_pair(m, octave_value());
+    }
+
+    octave_base_value *clone() const {
+      // pass-by-value is probably not desired, and is harder;
+      // requires calling copy constructors of contained types etc.
+      assert(0);
+      *(int *) 0 = 0;
+      return 0;
+    }
+
+    octave_base_value *empty_clone() const {
+      return new octave_swig_type();
+    }
+
+    bool is_defined() const {
+      return true;
+    }
+
+    virtual bool is_map() const {
+      return true;
+    }
+
+    virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
+      octave_value_list ovl = subsref(ops, idx, 1);
+      return ovl.length()? ovl(0) : octave_value();
+    }
+
+    virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
+      assert(ops.size() > 0);
+      assert(ops.size() == idx.size());
+
+      std::list < octave_value_list >::const_iterator idx_it = idx.begin();
+      int skip = 0;
+      octave_value_list sub_ovl;
+
+      // constructor invocation
+      if (ops[skip] == '(' && construct_type) {
+	assert(construct_type->clientdata);
+	swig_octave_class *c = (swig_octave_class *) construct_type->clientdata;
+	if (!c->constructor) {
+	  error("cannot create instance");
+	  return octave_value_list();
+	}
+	octave_value_list args;
+	if (c->director)
+	  args.append(Swig::swig_value_ref(new octave_swig_type(this, 0, 0)));
+	args.append(*idx_it++);
+	++skip;
+	sub_ovl = c->constructor(args, nargout);
+      }
+      // member dereference or invocation
+      else if (ops[skip] == '.') {
+	std::string subname;
+	const swig_type_info *base = 0;	// eg, a.base.base_cpp_mem
+	for (;;) {
+	  octave_value_list subname_ovl(*idx_it++);
+	  ++skip;
+	  assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
+	  subname = subname_ovl(0).string_value();
+
+	  const swig_type_info *next_base = find_base(subname, base);
+	  if (!next_base || skip >= (int) ops.size() || ops[skip] != '.')
+	    break;
+	  base = next_base;
+	}
+
+	member_value_pair tmp, *m = &tmp;
+	if (!base || !(m->first = find_member(base, subname)))
+	  m = find_member(subname, false);
+	if (!m) {
+	  error("member not found");
+	  return octave_value_list();
+	}
+
+	octave_value_list args;
+	if (!always_static &&
+	    (!m->first || (!m->first->is_static() && !m->first->is_global())))
+	  args.append(as_value());
+	if (skip < (int) ops.size() && ops[skip] == '(' && 
+	    ((m->first && m->first->method) || m->second.is_function() || 
+	     m->second.is_function_handle())) {
+	  args.append(*idx_it++);
+	  ++skip;
+	  sub_ovl = member_invoke(m, args, nargout);
+	} else {
+	  sub_ovl = member_deref(m, args);
+	}
+      }
+      // index operator
+      else {
+	if (ops[skip] == '(' || ops[skip] == '{') {
+	  const char *op_name = ops[skip] == '(' ? "__paren__" : "__brace__";
+	  octave_value_list args;
+	  args.append(*idx_it++);
+	  ++skip;
+	  if (!dispatch_index_op(op_name, args, sub_ovl)) {
+	    error("error evaluating index operator");
+	    return octave_value_list();
+	  }
+	} else {
+	  error("unsupported subsref");
+	  return octave_value_list();
+	}
+      }
+
+      if (skip >= (int) ops.size())
+	return sub_ovl;
+      if (sub_ovl.length() < 1) {
+	error("bad subs ref");
+	return octave_value_list();
+      }
+      return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
+    }
+
+    octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs) {
+      assert(ops.size() > 0);
+      assert(ops.size() == idx.size());
+
+      std::list < octave_value_list >::const_iterator idx_it = idx.begin();
+      int skip = 0;
+
+      if (ops.size() > 1) {
+	std::list < octave_value_list >::const_iterator last = idx.end();
+	--last;
+	std::list < octave_value_list > next_idx(idx.begin(), last);
+	octave_value next_ov = subsref(ops.substr(0, ops.size() - 1), next_idx);
+	next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
+      }
+
+      else if (ops[skip] == '(' || ops[skip] == '{') {
+	const char *op_name = ops[skip] == '(' ? "__paren_asgn__" : "__brace_asgn__";
+	member_value_pair *m = find_member(op_name, false);
+	if (m) {
+	  octave_value_list args;
+	  args.append(as_value());
+	  args.append(*idx_it);
+	  args.append(rhs);
+	  member_invoke(m, args, 1);
+	} else
+	  error("%s member not found", op_name);
+      }
+
+      else if (ops[skip] == '.') {
+	octave_value_list subname_ovl(*idx_it++);
+	++skip;
+	assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
+	std::string subname = subname_ovl(0).string_value();
+
+	member_value_pair *m = find_member(subname, true);
+	if (!m->first || !m->first->set_method) {
+	  m->first = 0;
+	  m->second = rhs;
+	} else if (m->first->set_method) {
+	  octave_value_list args;
+	  if (!m->first->is_static() && !m->first->is_global())
+	    args.append(as_value());
+	  args.append(rhs);
+	  m->first->set_method(args, 1);
+	} else
+	  error("member not assignable");
+      } else
+	error("unsupported subsasgn");
+
+      return as_value();
+    }
+
+    virtual bool is_object() const {
+      return true;
+    }
+
+    virtual bool is_string() const {
+      octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
+      return !!nc_this->find_member("__str__", false);
+    }
+
+    virtual std::string string_value(bool force = false) const {
+      octave_value ret;
+      if (!dispatch_unary_op("__str__", ret)) {
+        error("__str__ method not defined");
+        return std::string();
+      }
+      if (!ret.is_string()) {
+	error("__str__ method did not return a string");
+	return std::string();
+      }
+      return ret.string_value();
+    }
+
+    virtual double scalar_value(bool frc_str_conv = false) const {
+      octave_value ret;
+      if (!dispatch_unary_op("__float__", ret)) {
+        error("__float__ method not defined");
+      }
+      return ret.scalar_value();
+    }
+
+#if SWIG_OCTAVE_PREREQ(4,2,0)
+    virtual octave_value as_double(void) const {
+      octave_value ret;
+      if (!dispatch_unary_op("__float__", ret)) {
+        error("__float__ method not defined");
+      }
+      return ret.as_double();
+    }
+
+    virtual octave_value as_single(void) const {
+      octave_value ret;
+      if (!dispatch_unary_op("__float__", ret)) {
+        error("__float__ method not defined");
+      }
+      return ret.as_single();
+    }
+#endif
+
+#if SWIG_OCTAVE_PREREQ(3,8,0)
+    virtual octave_value map(octave_base_value::unary_mapper_t umap) const {
+      const std::string opname = std::string("__") + octave_base_value::get_umap_name(umap) + std::string("__");
+      octave_value ret;
+      if (!dispatch_unary_op(opname, ret)) {
+        error((opname + std::string(" method not found")).c_str());
+        return octave_value();
+      }
+      return ret;
+    }
+#endif
+
+#if SWIG_OCTAVE_PREREQ(3,3,52)
+    virtual octave_map map_value() const {
+      return octave_map();
+    }
+#else
+    virtual Octave_map map_value() const {
+      return Octave_map();
+    }
+#endif
+
+    virtual string_vector map_keys() const {
+      member_map tmp;
+      load_members(tmp);
+
+      string_vector keys(tmp.size());
+      int k = 0;
+      for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
+	keys(k++) = it->first;
+
+      return keys;
+    }
+
+    virtual bool save_ascii (std::ostream& os) {
+      return true;
+    }
+
+    virtual bool load_ascii (std::istream& is) {
+      return true;
+    }
+
+    virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
+      return true;
+    }
+
+    virtual bool load_binary (std::istream& is, bool swap, 
+			      oct_mach_info::float_format fmt) {
+      return true;
+    }
+
+#if defined (HAVE_HDF5)
+# if SWIG_OCTAVE_PREREQ(4,0,0)
+    virtual bool
+      save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats) {
+      return true;
+    }
+
+    virtual bool
+      load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug) {
+      return true;
+    }
+# else
+    virtual bool
+      save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
+      return true;
+    }
+
+    virtual bool
+      load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
+      return true;
+    }
+# endif
+#endif
+
+    virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const {
+      return string_value();
+    }
+
+    virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const {
+      return string_value();
+    }
+
+    static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret) {
+      // we assume that SWIG_op_prefix-prefixed functions are installed in global namespace
+      // (rather than any module namespace).
+
+      octave_function *fcn = is_valid_function(symbol, std::string(), false);
+      if (!fcn)
+	return false;
+      ret = fcn->do_multi_index_op(1, args)(0);
+      return true;
+    }
+
+    static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name) {
+      octave_swig_type *ost = Swig::swig_value_deref(x);
+      assert(ost);
+
+      octave_value ret;
+      if (ost->dispatch_unary_op(std::string("__") + op_name + std::string("__"), ret))
+	return ret;
+      std::string symbol = SWIG_op_prefix + ost->swig_type_name() + "_" + op_name;
+      octave_value_list args;
+      args.append(make_value_hack(x));
+      if (dispatch_global_op(symbol, args, ret))
+	return ret;
+
+      error("could not dispatch unary operator");
+      return octave_value();
+    }
+
+    static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name) {
+      octave_swig_type *lhs_ost = Swig::swig_value_deref(lhs);
+      octave_swig_type *rhs_ost = Swig::swig_value_deref(rhs);
+
+      octave_value ret;
+      if (lhs_ost && lhs_ost->dispatch_binary_op(std::string("__") + op_name + std::string("__"), rhs, ret))
+	return ret;
+      if (rhs_ost) {
+        if (strlen(op_name) == 2  && (op_name[1] == 't' || op_name[1] == 'e')) {
+          if (op_name[0] == 'l' && rhs_ost->dispatch_binary_op(std::string("__g") + op_name[1] + std::string("__"), lhs, ret))
+            return ret;
+          if (op_name[0] == 'g' && rhs_ost->dispatch_binary_op(std::string("__l") + op_name[1] + std::string("__"), lhs, ret))
+            return ret;
+        }
+        if (rhs_ost->dispatch_binary_op(std::string("__r") + op_name + std::string("__"), lhs, ret))
+          return ret;
+      }
+
+      std::string symbol;
+      octave_value_list args;
+      args.append(make_value_hack(lhs));
+      args.append(make_value_hack(rhs));
+
+      symbol = SWIG_op_prefix;
+      symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
+      symbol += "_";
+      symbol += op_name;
+      symbol += "_";
+      symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
+      if (dispatch_global_op(symbol, args, ret))
+	return ret;
+
+      symbol = SWIG_op_prefix;
+      symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
+      symbol += "_";
+      symbol += op_name;
+      symbol += "_";
+      symbol += "any";
+      if (dispatch_global_op(symbol, args, ret))
+	return ret;
+
+      symbol = SWIG_op_prefix;
+      symbol += "any";
+      symbol += "_";
+      symbol += op_name;
+      symbol += "_";
+      symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
+      if (dispatch_global_op(symbol, args, ret))
+	return ret;
+
+      error("could not dispatch binary operator");
+      return octave_value();
+    }
+
+#if SWIG_OCTAVE_PREREQ(4,0,0)
+    void print(std::ostream &os, bool pr_as_read_syntax = false)
+#else
+    void print(std::ostream &os, bool pr_as_read_syntax = false) const
+#endif
+    {
+      if (is_string()) {
+	os << string_value();
+	return;
+      }
+
+      member_map tmp;
+      load_members(tmp);
+
+      indent(os);
+      os << "{"; newline(os);
+      increment_indent_level();
+      for (unsigned int j = 0; j < types.size(); ++j) {
+        indent(os);
+	if (types[j].first->clientdata) {
+	  const swig_octave_class *c = (const swig_octave_class *) types[j].first->clientdata;
+	  os << c->name << ", ptr = " << types[j].second.ptr; newline(os);
+	} else {
+	  os << types[j].first->name << ", ptr = " << types[j].second.ptr; newline(os);
+	}
+      }
+      for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
+        indent(os);
+	if (it->second.first) {
+	  const char *objtype = it->second.first->method ? "method" : "variable";
+	  const char *modifier = (it->second.first->flags &1) ? "static " : (it->second.first->flags &2) ? "global " : "";
+	  os << it->second.first->name << " (" << modifier << objtype << ")"; newline(os);
+	  assert(it->second.first->name == it->first);
+	} else {
+	  os << it->first; newline(os);
+	}
+      }
+      decrement_indent_level();
+      indent(os);
+      os << "}"; newline(os);
+    }
+  };
+
+  // Octave tries hard to preserve pass-by-value semantics. Eg, assignments
+  // will call clone() via make_unique() if there is more than one outstanding 
+  // reference to the lhs, and forces the clone's reference count to 1 
+  // (so you can't just increment your own count and return this).
+  //
+  // One way to fix this (without modifying Octave) is to add a level of
+  // indirection such that clone copies ref-counted pointer and we keep 
+  // pass-by-ref semantics (which are more natural/expected for C++ bindings).
+  //
+  // Supporting both pass-by-{ref,value} and toggling via %feature/option 
+  // might be nice.
+
+  class octave_swig_ref:public octave_base_value {
+    octave_swig_type *ptr;
+  public:
+    octave_swig_ref(octave_swig_type *_ptr = 0)
+      :ptr(_ptr) { }
+
+    ~octave_swig_ref()
+      { if (ptr) ptr->decref(); }
+
+    octave_swig_type *get_ptr() const
+      { return ptr; }
+
+    octave_base_value *clone() const
+      { if (ptr) ptr->incref(); return new octave_swig_ref(ptr); }
+
+    octave_base_value *empty_clone() const
+      { return new octave_swig_ref(0); }
+
+    dim_vector dims(void) const 
+      { return ptr->dims(); }
+
+    bool is_defined() const
+      { return ptr->is_defined(); }
+
+    virtual bool is_map() const 
+      { return ptr->is_map(); }
+
+    virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) 
+      { return ptr->subsref(ops, idx); }
+
+    virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout)
+      { return ptr->subsref(ops, idx, nargout); }
+
+    octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs)
+      { return ptr->subsasgn(ops, idx, rhs); }
+
+    virtual bool is_object() const 
+      { return ptr->is_object(); }
+
+    virtual bool is_string() const 
+      { return ptr->is_string(); }
+
+    virtual std::string string_value(bool force = false) const 
+      { return ptr->string_value(force); }
+
+    virtual double scalar_value(bool frc_str_conv = false) const
+      { return ptr->scalar_value(frc_str_conv); }
+
+#if SWIG_OCTAVE_PREREQ(4,2,0)
+    virtual octave_value as_double(void) const
+      { return ptr->as_double(); }
+
+    virtual octave_value as_single(void) const
+      { return ptr->as_single(); }
+#endif
+
+#if SWIG_OCTAVE_PREREQ(3,8,0)
+    virtual octave_value map(octave_base_value::unary_mapper_t umap) const
+      { return ptr->map(umap); }
+#endif
+
+#if SWIG_OCTAVE_PREREQ(3,3,52)
+    virtual octave_map map_value() const
+      { return ptr->map_value(); }
+#else
+    virtual Octave_map map_value() const
+      { return ptr->map_value(); }
+#endif
+
+    virtual string_vector map_keys() const
+      { return ptr->map_keys(); }
+
+    virtual bool save_ascii (std::ostream& os)
+      { return ptr->save_ascii(os); }
+
+    virtual bool load_ascii (std::istream& is)
+      { return ptr->load_ascii(is); }
+
+    virtual bool save_binary (std::ostream& os, bool& save_as_floats)
+      { return ptr->save_binary(os, save_as_floats); }
+
+    virtual bool load_binary (std::istream& is, bool swap, 
+			      oct_mach_info::float_format fmt)
+      { return ptr->load_binary(is, swap, fmt); }
+
+#if defined (HAVE_HDF5)
+# if SWIG_OCTAVE_PREREQ(4,0,0)
+    virtual bool
+      save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats)
+      { return ptr->save_hdf5(loc_id, name, save_as_floats); }
+
+    virtual bool
+      load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug)
+      { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
+# else
+    virtual bool
+      save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats)
+      { return ptr->save_hdf5(loc_id, name, save_as_floats); }
+
+    virtual bool
+      load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug)
+      { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
+# endif
+#endif
+
+    virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const
+      { return ptr->convert_to_str(pad, force, type); }
+
+    virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
+      { return ptr->convert_to_str_internal(pad, force, type); }
+
+#if SWIG_OCTAVE_PREREQ(4,0,0)
+    void print(std::ostream &os, bool pr_as_read_syntax = false)
+#else
+    void print(std::ostream &os, bool pr_as_read_syntax = false) const
+#endif
+      { return ptr->print(os, pr_as_read_syntax); }
+
+    virtual type_conv_info numeric_conversion_function(void) const {
+      return octave_base_value::type_conv_info (default_numeric_conversion_function,
+                                                octave_scalar::static_type_id ());
+    }
+
+  private:
+    static octave_base_value *default_numeric_conversion_function (const octave_base_value& a) {
+      const octave_swig_ref& v = dynamic_cast<const octave_swig_ref&>(a);
+      return new octave_scalar(v.scalar_value());
+    }
+
+#if !SWIG_OCTAVE_PREREQ(4,0,0)
+    DECLARE_OCTAVE_ALLOCATOR;
+#endif
+    DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA;
+  };
+#if !SWIG_OCTAVE_PREREQ(4,0,0)
+  DEFINE_OCTAVE_ALLOCATOR(octave_swig_ref);
+#endif
+  DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_ref, "swig_ref", "swig_ref");
+
+  class octave_swig_packed:public octave_base_value {
+    swig_type_info *type;
+    std::vector < char > buf;
+  public:
+
+    octave_swig_packed(swig_type_info *_type = 0, const void *_buf = 0, size_t _buf_len = 0)
+      :	type(_type), buf((const char*)_buf, (const char*)_buf + _buf_len) {
+    }
+
+    bool copy(swig_type_info *outtype, void *ptr, size_t sz) const {
+      if (outtype && outtype != type)
+	return false;
+      assert(sz <= buf.size());
+      std::copy(buf.begin(), buf.begin()+sz, (char*)ptr);
+      return true;
+    }
+
+    octave_base_value *clone() const {
+      return new octave_swig_packed(*this);
+    }
+
+    octave_base_value *empty_clone() const {
+      return new octave_swig_packed();
+    }
+
+    bool is_defined() const {
+      return true;
+    }
+
+#if SWIG_OCTAVE_PREREQ(4,0,0)
+    void print(std::ostream &os, bool pr_as_read_syntax = false)
+#else
+    void print(std::ostream &os, bool pr_as_read_syntax = false) const
+#endif
+    {
+      indent(os);
+      os << "swig packed type: name = " << (type ? type->name : std::string()) << ", len = " << buf.size(); newline(os);
+    }
+
+
+    virtual bool save_ascii (std::ostream& os) {
+      return true;
+    }
+
+    virtual bool load_ascii (std::istream& is) {
+      return true;
+    }
+
+    virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
+      return true;
+    }
+
+    virtual bool load_binary (std::istream& is, bool swap, 
+			      oct_mach_info::float_format fmt) {
+      return true;
+    }
+
+#if defined (HAVE_HDF5)
+# if SWIG_OCTAVE_PREREQ(4,0,0)
+    virtual bool
+      save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats) {
+      return true;
+    }
+
+    virtual bool
+      load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug) {
+      return true;
+    }
+# else
+    virtual bool
+      save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
+      return true;
+    }
+
+    virtual bool
+      load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
+      return true;
+    }
+# endif
+#endif
+
+  private:
+#if !SWIG_OCTAVE_PREREQ(4,0,0)
+    DECLARE_OCTAVE_ALLOCATOR;
+#endif
+    DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA;
+  };
+#if !SWIG_OCTAVE_PREREQ(4,0,0)
+  DEFINE_OCTAVE_ALLOCATOR(octave_swig_packed);
+#endif
+  DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_packed, "swig_packed", "swig_packed");
+
+  SWIGRUNTIME octave_value_list octave_set_immutable(const octave_value_list &args, int nargout) {
+    error("attempt to set immutable member variable");
+    return octave_value_list();
+  }
+
+  struct octave_value_ref {
+    const octave_value_list &ovl;
+    int j;
+
+    octave_value_ref(const octave_value_list &_ovl, int _j)
+      :ovl(_ovl), j(_j) { }
+
+    operator  octave_value() const {
+      return ovl(j);
+    }
+
+    octave_value operator*() const {
+      return ovl(j);
+    }
+  };
+
+
+namespace Swig {
+
+  SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost) {
+    return new octave_swig_ref(ost);
+  }
+
+  SWIGRUNTIME octave_swig_type *swig_value_deref(octave_value ov) {
+    if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
+      ov = ov.cell_value()(0);
+    return swig_value_deref(*ov.internal_rep());
+  }
+
+  SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov) {
+    if (ov.type_id() != octave_swig_ref::static_type_id())
+      return 0;
+    const octave_swig_ref *osr = static_cast < const octave_swig_ref *>(&ov);
+    return osr->get_ptr();
+  }
+
+}
+
+
+#define swig_unary_op(name) \
+SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
+  return octave_swig_type::dispatch_unary_op(x,#name); \
+}
+#define swig_binary_op(name) \
+SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
+  return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
+}
+#define swigreg_unary_op(name) \
+if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
+octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
+#define swigreg_binary_op(name) \
+if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
+octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
+
+  swig_unary_op(not);
+  swig_unary_op(uplus);
+  swig_unary_op(uminus);
+  swig_unary_op(transpose);
+  swig_unary_op(hermitian);
+  swig_unary_op(incr);
+  swig_unary_op(decr);
+
+  swig_binary_op(add);
+  swig_binary_op(sub);
+  swig_binary_op(mul);
+  swig_binary_op(div);
+  swig_binary_op(pow);
+  swig_binary_op(ldiv);
+#if !SWIG_OCTAVE_PREREQ(4,2,0)
+  swig_binary_op(lshift);
+  swig_binary_op(rshift);
+#endif
+  swig_binary_op(lt);
+  swig_binary_op(le);
+  swig_binary_op(eq);
+  swig_binary_op(ge);
+  swig_binary_op(gt);
+  swig_binary_op(ne);
+  swig_binary_op(el_mul);
+  swig_binary_op(el_div);
+  swig_binary_op(el_pow);
+  swig_binary_op(el_ldiv);
+  swig_binary_op(el_and);
+  swig_binary_op(el_or);
+
+  SWIGRUNTIME void SWIG_InstallUnaryOps(int tid) {
+    swigreg_unary_op(not);
+    swigreg_unary_op(uplus);
+    swigreg_unary_op(uminus);
+    swigreg_unary_op(transpose);
+    swigreg_unary_op(hermitian);
+    swigreg_unary_op(incr);
+    swigreg_unary_op(decr);
+  }
+  SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2) {
+    swigreg_binary_op(add);
+    swigreg_binary_op(sub);
+    swigreg_binary_op(mul);
+    swigreg_binary_op(div);
+    swigreg_binary_op(pow);
+    swigreg_binary_op(ldiv);
+#if !SWIG_OCTAVE_PREREQ(4,2,0)
+    swigreg_binary_op(lshift);
+    swigreg_binary_op(rshift);
+#endif
+    swigreg_binary_op(lt);
+    swigreg_binary_op(le);
+    swigreg_binary_op(eq);
+    swigreg_binary_op(ge);
+    swigreg_binary_op(gt);
+    swigreg_binary_op(ne);
+    swigreg_binary_op(el_mul);
+    swigreg_binary_op(el_div);
+    swigreg_binary_op(el_pow);
+    swigreg_binary_op(el_ldiv);
+    swigreg_binary_op(el_and);
+    swigreg_binary_op(el_or);
+  }
+  SWIGRUNTIME void SWIG_InstallOps(int tid) {
+    // here we assume that tid are conseq integers increasing from zero, and 
+    // that our tid is the last one. might be better to have explicit string 
+    // list of types we should bind to, and use lookup_type to resolve their tid.
+
+    SWIG_InstallUnaryOps(tid);
+    SWIG_InstallBinaryOps(tid, tid);
+    for (int j = 0; j < tid; ++j) {
+      SWIG_InstallBinaryOps(j, tid);
+      SWIG_InstallBinaryOps(tid, j);
+    }
+  }
+
+SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
+  int own = (flags &SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
+
+#ifdef SWIG_DIRECTORS
+  Swig::Director *d = Swig::get_rtdir(ptr);
+  if (d && Swig::swig_director_get_self(d))
+    return Swig::swig_director_get_self(d)->as_value();
+#endif
+  return Swig::swig_value_ref(new octave_swig_type(ptr, type, own));
+}
+
+SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own) {
+  if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
+    ov = ov.cell_value()(0);
+  if (!ov.is_defined() ||
+      (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
+    if (ptr)
+      *ptr = 0;
+    return SWIG_OK;
+  }
+  if (ov.type_id() != octave_swig_ref::static_type_id())
+    return SWIG_ERROR;
+  octave_swig_ref *osr = static_cast < octave_swig_ref *>(ov.internal_rep());
+  octave_swig_type *ost = osr->get_ptr();
+  return ost->cast(ptr, type, own, flags);
+}
+
+SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
+  return new octave_swig_packed(type, (char *) ptr, sz);
+}
+
+SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type) {
+  if (!ov.is_defined())
+    return SWIG_ERROR;
+  if (ov.type_id() != octave_swig_packed::static_type_id())
+    return SWIG_ERROR;
+  octave_swig_packed *ost = static_cast < octave_swig_packed *>(ov.internal_rep());
+  return ost->copy(type, (char *) ptr, sz) ? SWIG_OK : SWIG_ERROR;
+}
+
+SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov) {
+  module_ns->assign(name, ov);
+}
+
+SWIGRUNTIMEINLINE octave_value SWIG_Octave_GetGlobalValue(std::string name) {
+  return get_global_value(name, true);
+}
+
+SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value& value) {
+  set_global_value(name, value);
+}
+
+SWIGRUNTIME void SWIG_Octave_LinkGlobalValue(std::string name) {
+#if !SWIG_OCTAVE_PREREQ(3,2,0)
+  link_to_global_variable(curr_sym_tab->lookup(name, true));
+#else
+#if !SWIG_OCTAVE_PREREQ(3,8,0)
+  symbol_table::varref(name);
+#endif
+  symbol_table::mark_global(name);
+#endif
+}
+
+SWIGRUNTIME swig_module_info *SWIG_Octave_GetModule(void *clientdata) {
+  octave_value ov = SWIG_Octave_GetGlobalValue("__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION);
+  if (!ov.is_defined() ||
+      ov.type_id() != octave_swig_packed::static_type_id())
+    return 0;
+  const octave_swig_packed* osp = 
+    static_cast < const octave_swig_packed *> (ov.internal_rep());
+  swig_module_info *pointer = 0;
+  osp->copy(0, &pointer, sizeof(swig_module_info *));
+  return pointer;
+}
+
+SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer) {
+  octave_value ov = new octave_swig_packed(0, &pointer, sizeof(swig_module_info *));
+  SWIG_Octave_SetGlobalValue("__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION, ov);
+}
diff --git a/share/swig/3.0.12/octave/octruntime.swg b/share/swig/3.0.12/octave/octruntime.swg
new file mode 100644
index 0000000..f5e6871
--- /dev/null
+++ b/share/swig/3.0.12/octave/octruntime.swg
@@ -0,0 +1,452 @@
+%insert(runtime) %{
+
+#include <cstdlib>
+#include <iostream>
+
+#include <octave/oct.h>
+#include <octave/version.h>
+
+// Macro for enabling features which require Octave version >= major.minor.patch
+// - Use (OCTAVE_PATCH_VERSION + 0) to handle both '<digit>' (released) and '<digit>+' (in development) patch numbers
+#define SWIG_OCTAVE_PREREQ(major, minor, patch) \
+  ( (OCTAVE_MAJOR_VERSION<<16) + (OCTAVE_MINOR_VERSION<<8) + (OCTAVE_PATCH_VERSION + 0) >= ((major)<<16) + ((minor)<<8) + (patch) )
+
+// Reconstruct Octave major, minor, and patch versions for releases prior to 3.8.1
+#if !defined(OCTAVE_MAJOR_VERSION)
+
+# if !defined(OCTAVE_API_VERSION_NUMBER)
+
+// Hack to distinguish between Octave 3.8.0, which removed OCTAVE_API_VERSION_NUMBER but did not yet
+// introduce OCTAVE_MAJOR_VERSION, and Octave <= 3.2, which did not define OCTAVE_API_VERSION_NUMBER
+#  include <octave/ov.h>
+#  if defined(octave_ov_h)
+#   define OCTAVE_MAJOR_VERSION 3
+#   define OCTAVE_MINOR_VERSION 8
+#   define OCTAVE_PATCH_VERSION 0
+#  else
+
+// Hack to distinguish between Octave 3.2 and earlier versions, before OCTAVE_API_VERSION_NUMBER existed
+#   define ComplexLU __ignore
+#   include <octave/CmplxLU.h>
+#   undef ComplexLU
+#   if defined(octave_Complex_LU_h)
+
+// We know only that this version is prior to Octave 3.2, i.e. OCTAVE_API_VERSION_NUMBER < 37
+#    define OCTAVE_MAJOR_VERSION 3
+#    define OCTAVE_MINOR_VERSION 1
+#    define OCTAVE_PATCH_VERSION 99
+
+#   else
+
+// OCTAVE_API_VERSION_NUMBER == 37
+#    define OCTAVE_MAJOR_VERSION 3
+#    define OCTAVE_MINOR_VERSION 2
+#    define OCTAVE_PATCH_VERSION 0
+
+#   endif // defined(octave_Complex_LU_h)
+
+#  endif // defined(octave_ov_h)
+
+// Correlation between Octave API and version numbers extracted from Octave's
+// ChangeLogs; version is the *earliest* released Octave with that API number
+# elif OCTAVE_API_VERSION_NUMBER >= 48
+#  define OCTAVE_MAJOR_VERSION 3
+#  define OCTAVE_MINOR_VERSION 6
+#  define OCTAVE_PATCH_VERSION 0
+
+# elif OCTAVE_API_VERSION_NUMBER >= 45
+#  define OCTAVE_MAJOR_VERSION 3
+#  define OCTAVE_MINOR_VERSION 4
+#  define OCTAVE_PATCH_VERSION 1
+
+# elif OCTAVE_API_VERSION_NUMBER >= 42
+#  define OCTAVE_MAJOR_VERSION 3
+#  define OCTAVE_MINOR_VERSION 3
+#  define OCTAVE_PATCH_VERSION 54
+
+# elif OCTAVE_API_VERSION_NUMBER >= 41
+#  define OCTAVE_MAJOR_VERSION 3
+#  define OCTAVE_MINOR_VERSION 3
+#  define OCTAVE_PATCH_VERSION 53
+
+# elif OCTAVE_API_VERSION_NUMBER >= 40
+#  define OCTAVE_MAJOR_VERSION 3
+#  define OCTAVE_MINOR_VERSION 3
+#  define OCTAVE_PATCH_VERSION 52
+
+# elif OCTAVE_API_VERSION_NUMBER >= 39
+#  define OCTAVE_MAJOR_VERSION 3
+#  define OCTAVE_MINOR_VERSION 3
+#  define OCTAVE_PATCH_VERSION 51
+
+# else // OCTAVE_API_VERSION_NUMBER == 38
+#  define OCTAVE_MAJOR_VERSION 3
+#  define OCTAVE_MINOR_VERSION 3
+#  define OCTAVE_PATCH_VERSION 50
+
+# endif // !defined(OCTAVE_API_VERSION_NUMBER)
+
+#endif // !defined(OCTAVE_MAJOR_VERSION)
+
+#include <octave/Cell.h>
+#include <octave/dynamic-ld.h>
+#include <octave/oct-env.h>
+#include <octave/oct-map.h>
+#include <octave/ov-scalar.h>
+#include <octave/ov-fcn-handle.h>
+#include <octave/parse.h>
+#if SWIG_OCTAVE_PREREQ(4,2,0)
+#include <octave/interpreter.h>
+#else
+#include <octave/toplev.h>
+#endif
+#include <octave/unwind-prot.h>
+#if SWIG_OCTAVE_PREREQ(4,2,0)
+#include <octave/call-stack.h>
+#endif
+
+%}
+
+%insert(runtime) "swigrun.swg";
+%insert(runtime) "swigerrors.swg";
+%insert(runtime) "octrun.swg";
+
+%insert(initbeforefunc) "swiginit.swg"
+
+%insert(initbeforefunc) %{
+
+static bool SWIG_init_user(octave_swig_type* module_ns);
+
+SWIGINTERN bool SWIG_Octave_LoadModule(std::string name) {
+  bool retn = false;
+  {
+#if SWIG_OCTAVE_PREREQ(4,2,0)
+    octave::unwind_protect frame;
+    frame.protect_var(discard_error_messages);          discard_error_messages = true;
+    frame.protect_var(discard_warning_messages);        discard_warning_messages = true;
+#elif SWIG_OCTAVE_PREREQ(3,3,50)
+    unwind_protect frame;
+    frame.protect_var(error_state);                     error_state = 0;
+    frame.protect_var(warning_state);                   warning_state = 0;
+    frame.protect_var(discard_error_messages);          discard_error_messages = true;
+    frame.protect_var(discard_warning_messages);        discard_warning_messages = true;
+#else
+    unwind_protect::begin_frame("SWIG_Octave_LoadModule");
+    unwind_protect_int(error_state);                    error_state = 0;
+    unwind_protect_int(warning_state);                  warning_state = 0;
+    unwind_protect_bool(discard_error_messages);        discard_error_messages = true;
+    unwind_protect_bool(discard_warning_messages);      discard_warning_messages = true;
+#endif
+#if SWIG_OCTAVE_PREREQ(4,2,0)
+    try {
+      feval(name, octave_value_list(), 0);
+      retn = true;
+    } catch (octave::execution_exception&) { }
+#else
+    feval(name, octave_value_list(), 0);
+    retn = (error_state == 0);
+#endif
+#if !SWIG_OCTAVE_PREREQ(3,3,50)
+    unwind_protect::run_frame("SWIG_Octave_LoadModule");
+#endif
+  }
+  if (!retn) {
+    error(SWIG_name_d ": could not load module `%s'", name.c_str());
+  }
+  return retn;
+}
+
+SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name) {
+  bool retn = false;
+  {
+#if SWIG_OCTAVE_PREREQ(4,2,0)
+    octave::unwind_protect frame;
+    frame.protect_var(discard_error_messages);          discard_error_messages = true;
+    frame.protect_var(discard_warning_messages);        discard_warning_messages = true;
+#elif SWIG_OCTAVE_PREREQ(3,3,50)
+    unwind_protect frame;
+    frame.protect_var(error_state);                     error_state = 0;
+    frame.protect_var(warning_state);                   warning_state = 0;
+    frame.protect_var(discard_error_messages);          discard_error_messages = true;
+    frame.protect_var(discard_warning_messages);        discard_warning_messages = true;
+#else
+    unwind_protect::begin_frame("SWIG_Octave_LoadModule");
+    unwind_protect_int(error_state);                    error_state = 0;
+    unwind_protect_int(warning_state);                  warning_state = 0;
+    unwind_protect_bool(discard_error_messages);        discard_error_messages = true;
+    unwind_protect_bool(discard_warning_messages);      discard_warning_messages = true;
+#endif
+    octave_value_list args;
+    args.append(name);
+    args.append(octloadfcn->fcn_file_name());
+#if SWIG_OCTAVE_PREREQ(4,2,0)
+    try {
+      feval("autoload", args, 0);
+      retn = true;
+    } catch (octave::execution_exception&) { }
+#else
+    feval("autoload", args, 0);
+    retn = (error_state == 0);
+#endif
+#if !SWIG_OCTAVE_PREREQ(3,3,50)
+    unwind_protect::run_frame("SWIG_Octave_InstallFunction");
+#endif
+  }
+  if (!retn) {
+    error(SWIG_name_d ": could not load function `%s'", name.c_str());
+  }
+  return retn;
+}
+
+static const char *const subclass_usage = "-*- texinfo -*- \n\
+@deftypefn {Loadable Function} {} subclass()\n\
+@deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
+Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
+\n\
+See the SWIG manual for usage examples.\n\
+@end deftypefn";
+
+DEFUN_DLD( subclass, args, nargout, subclass_usage ) {
+  octave_swig_type *top = new octave_swig_type;
+  for (int j = 0; j < args.length(); ++j) {
+    if (args(j).type_id() == octave_swig_ref::static_type_id()) {
+      octave_swig_ref *osr = static_cast < octave_swig_ref *>(args(j).internal_rep());
+      octave_swig_type *ost = osr->get_ptr();
+      if (!ost->is_owned()) {
+        error("subclass: cannot subclass object not constructed on octave side");
+        return octave_value_list();
+      }
+      top->merge(*ost);
+    } else if (args(j).is_function_handle()) {
+      top->assign(args(j).fcn_handle_value()->fcn_name(), args(j));
+    } else if (args(j).is_string()) {
+      if (j + 1 >= args.length()) {
+        error("subclass: member assignments must be of string,value form");
+        return octave_value_list();
+      }
+      top->assign(args(j).string_value(), args(j + 1));
+      ++j;
+    } else {
+      error("subclass: invalid arguments to subclass()");
+      return octave_value_list();
+    }
+  }
+  return octave_value(Swig::swig_value_ref(top));
+}
+
+static const char *const swig_type_usage = "-*- texinfo -*- \n\
+@deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
+Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
+@end deftypefn";
+
+DEFUN_DLD( swig_type, args, nargout, swig_type_usage ) {
+  if (args.length() != 1) {
+    error("swig_type: must be called with only a single object");
+    return octave_value_list();
+  }
+  octave_swig_type *ost = Swig::swig_value_deref(args(0));
+  if (!ost) {
+    error("swig_type: object is not a swig_ref");
+    return octave_value_list();
+  }
+  return octave_value(ost->swig_type_name());
+}
+
+static const char *const swig_typequery_usage = "-*- texinfo -*- \n\
+@deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
+Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
+otherwise return `<unknown>'.\n\
+@end deftypefn";
+
+DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
+  if (args.length() != 1 || !args(0).is_string()) {
+    error("swig_typequery: must be called with single string argument");
+    return octave_value_list();
+  }
+  swig_module_info *module = SWIG_GetModule(0);
+  swig_type_info *type = SWIG_TypeQueryModule(module, module, args(0).string_value().c_str());
+  if (!type)
+    return octave_value("<unknown>");
+  return octave_value(type->name);
+}
+
+static const char *const swig_this_usage = "-*- texinfo -*- \n\
+@deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
+Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
+@end deftypefn";
+
+DEFUN_DLD( swig_this, args, nargout, swig_this_usage ) {
+  if (args.length() != 1) {
+    error("swig_this: must be called with only a single object");
+    return octave_value_list();
+  }
+  if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
+    return octave_value(octave_uint64(0));
+  octave_swig_type *ost = Swig::swig_value_deref(args(0));
+  if (!ost) {
+    error("swig_this: object is not a swig_ref");
+    return octave_value_list();
+  }
+  return octave_value(octave_uint64((unsigned long long) ost->swig_this()));
+}
+
+static const char *const swig_octave_prereq_usage = "-*- texinfo -*- \n\
+@deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\
+Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\
+@end deftypefn";
+
+DEFUN_DLD( swig_octave_prereq, args, nargout, swig_octave_prereq_usage ) {
+  if (args.length() != 3) {
+    error("swig_octave_prereq: must be called with 3 arguments");
+    return octave_value_list();
+  }
+  const int major = args(0).int_value();
+  const int minor = args(1).int_value();
+  const int patch = args(2).int_value();
+  const bool prereq = SWIG_OCTAVE_PREREQ(major, minor, patch);
+  return octave_value(prereq);
+}
+
+static const char *const SWIG_name_usage = "-*- texinfo -*- \n\
+@deftypefn {Loadable Module} {} " SWIG_name_d "\n\
+Loads the SWIG-generated module `" SWIG_name_d "'.\n\
+@end deftypefn";
+
+DEFUN_DLD( SWIG_name, args, nargout, SWIG_name_usage ) {
+
+  static octave_swig_type* module_ns = 0;
+
+  // workaround to prevent octave seg-faulting on exit: set Octave exit function
+  // octave_exit to _Exit, which exits immediately without trying to cleanup memory.
+  // definitely affected version 3.2.*, not sure about 3.3.*, seems to be fixed in
+  // version 3.4.*, but reappeared in 4.2.*, so turn on for all versions after 3.2.*.
+  // can be turned off with macro definition.
+#ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
+#if SWIG_OCTAVE_PREREQ(3,2,0)
+  octave_exit = ::_Exit;
+#endif
+#endif
+
+  // check for no input and output args
+  if (args.length() != 0 || nargout != 0) {
+    print_usage();
+    return octave_value_list();
+  }
+
+  // create module on first function call
+  if (!module_ns) {
+
+    // workaround bug in octave where installing global variable of custom type and then
+    // exiting without explicitly clearing the variable causes octave to segfault.
+#if SWIG_OCTAVE_PREREQ(3,2,0)
+    octave_value_list eval_args;
+    eval_args.append("base");
+    eval_args.append("function __swig_atexit__; "
+                     "  if mislocked() "
+                     "    clear -all; "
+                     "  else "
+                     "    mlock(); "
+                     "  endif; "
+                     "endfunction; "
+                     "__swig_atexit__; "
+                     "atexit(\"__swig_atexit__\", false); "
+                     "atexit(\"__swig_atexit__\")");
+    feval("evalin", eval_args, 0);
+#endif
+
+    octave_swig_ref::register_type();
+    octave_swig_packed::register_type();
+    SWIG_InitializeModule(0);
+    SWIG_PropagateClientData();
+
+    octave_function *me = octave_call_stack::current();
+
+    if (!SWIG_Octave_InstallFunction(me, "subclass")) {
+      return octave_value_list();
+    }
+    if (!SWIG_Octave_InstallFunction(me, "swig_type")) {
+      return octave_value_list();
+    }
+    if (!SWIG_Octave_InstallFunction(me, "swig_typequery")) {
+      return octave_value_list();
+    }
+    if (!SWIG_Octave_InstallFunction(me, "swig_this")) {
+      return octave_value_list();
+    }
+    if (!SWIG_Octave_InstallFunction(me, "swig_octave_prereq")) {
+      return octave_value_list();
+    }
+
+    octave_swig_type* cvar_ns=0;
+    if (std::string(SWIG_global_name) != ".") {
+      cvar_ns=new octave_swig_type;
+      for (int j=0;swig_globals[j].name;++j)
+        if (swig_globals[j].get_method)
+          cvar_ns->assign(swig_globals[j].name,&swig_globals[j]);
+    }
+
+    module_ns=new octave_swig_type(0, 0, 0, true);
+    if (std::string(SWIG_global_name) != ".") {
+      module_ns->assign(SWIG_global_name,Swig::swig_value_ref(cvar_ns));
+    }
+    else {
+      for (int j=0;swig_globals[j].name;++j)
+        if (swig_globals[j].get_method)
+          module_ns->assign(swig_globals[j].name,&swig_globals[j]);
+    }
+    for (int j=0;swig_globals[j].name;++j)
+      if (swig_globals[j].method)
+        module_ns->assign(swig_globals[j].name,&swig_globals[j]);
+
+    // * need better solution here; swig_type -> octave_class mapping is
+    // * really n-to-1, in some cases such as template partial spec, etc.
+    // * see failing tests.
+    for (int j=0;swig_types[j];++j)
+      if (swig_types[j]->clientdata) {
+        swig_octave_class* c=(swig_octave_class*)swig_types[j]->clientdata;
+        module_ns->assign(c->name,
+                        Swig::swig_value_ref
+                        (new octave_swig_type(0,swig_types[j])));
+      }
+
+    if (!SWIG_init_user(module_ns)) {
+      delete module_ns;
+      module_ns=0;
+      return octave_value_list();
+    }
+
+    SWIG_InstallOps(octave_swig_ref::static_type_id());
+
+    octave_swig_type::swig_member_const_iterator mb;
+    for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
+      if (mb->second.first && mb->second.first->method) {
+        if (!SWIG_Octave_InstallFunction(me, mb->first)) {
+          return octave_value_list();
+        }
+      }
+    }
+
+#if !SWIG_OCTAVE_PREREQ(3,2,0)
+    mlock(me->name());
+#else
+    mlock();
+#endif
+
+  }
+
+  octave_swig_type::swig_member_const_iterator mb;
+  for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
+    if (mb->second.second.is_defined()) {
+      SWIG_Octave_SetGlobalValue(mb->first, mb->second.second);
+      SWIG_Octave_LinkGlobalValue(mb->first);
+    }
+  }
+
+  SWIG_Octave_SetGlobalValue(SWIG_name_d, module_ns->as_value());
+  SWIG_Octave_LinkGlobalValue(SWIG_name_d);
+
+  return octave_value_list();
+
+}
+
+%}
diff --git a/share/swig/3.0.12/octave/octstdcommon.swg b/share/swig/3.0.12/octave/octstdcommon.swg
new file mode 100644
index 0000000..799d369
--- /dev/null
+++ b/share/swig/3.0.12/octave/octstdcommon.swg
@@ -0,0 +1,227 @@
+%fragment("StdTraits","header",fragment="StdTraitsCommon")
+{
+namespace swig {  
+// Traits that provides the from method
+  template <class Type> struct traits_from_ptr {
+    static octave_value from(Type *val, int owner = 0) {
+      return SWIG_NewPointerObj(val, type_info<Type>(), owner);
+    }
+  };
+
+  template <class Type> struct traits_from {
+    static octave_value from(const Type& val) {
+      return traits_from_ptr<Type>::from(new Type(val), 1);
+    }
+  };
+
+  template <class Type> struct traits_from<Type *> {
+    static octave_value from(Type* val) {
+      return traits_from_ptr<Type>::from(val, 0);
+    }
+  };
+
+  template <class Type> struct traits_from<const Type *> {
+    static octave_value from(const Type* val) {
+      return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
+    }
+  };
+
+
+  template <class Type>
+  inline octave_value from(const Type& val) {
+    return traits_from<Type>::from(val);
+  }
+
+  template <class Type>
+  inline octave_value from_ptr(Type* val, int owner) {
+    return traits_from_ptr<Type>::from(val, owner);
+  }
+
+    // Traits that provides the asval/as/check method
+  template <class Type>
+  struct traits_asptr {   
+    static int asptr(const octave_value& obj, Type **val) {
+      Type *p;
+      swig_type_info *descriptor = type_info<Type>();
+      int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
+      if (SWIG_IsOK(res)) {
+	if (val) *val = p;
+      }
+      return res;
+    }
+  }; 
+
+  template <class Type>
+  inline int asptr(const octave_value& obj, Type **vptr) {
+    return traits_asptr<Type>::asptr(obj, vptr);
+  }
+
+  template <class Type> 
+  struct traits_asval {
+    static int asval(const octave_value& obj, Type *val) {
+      if (val) {
+	Type *p = 0;
+	int res = traits_asptr<Type>::asptr(obj, &p);
+	if (!SWIG_IsOK(res)) return res;	
+	if (p) {
+	  typedef typename noconst_traits<Type>::noconst_type noconst_type;
+	  *(const_cast<noconst_type*>(val)) = *p;
+	  if (SWIG_IsNewObj(res)){
+	    %delete(p);
+	    res = SWIG_DelNewMask(res);
+	  }
+	  return res;
+	} else {
+	  return SWIG_ERROR;
+	}
+      } else {
+	return traits_asptr<Type>::asptr(obj, (Type **)(0));
+      }
+    }
+  };
+
+  template <class Type> struct traits_asval<Type*> {
+    static int asval(const octave_value& obj, Type **val) {
+      if (val) {
+        typedef typename noconst_traits<Type>::noconst_type noconst_type;
+        noconst_type *p = 0;
+        int res = traits_asptr<noconst_type>::asptr(obj,  &p);
+        if (SWIG_IsOK(res)) {
+          *(const_cast<noconst_type**>(val)) = p;
+	}
+	return res;
+      } else {
+	return traits_asptr<Type>::asptr(obj, (Type **)(0));
+      }
+    }
+  };
+  
+  template <class Type>
+  inline int asval(const octave_value& obj, Type *val) {
+    return traits_asval<Type>::asval(obj, val);
+  }
+
+  template <class Type> 
+  struct traits_as<Type, value_category> {
+    static Type as(const octave_value& obj, bool throw_error) {
+      Type v;
+      int res = asval(obj, &v);
+      if (!obj.is_defined() || !SWIG_IsOK(res)) {
+	if (!Octave_Error_Occurred()) {
+	  %type_error(swig::type_name<Type>());
+	}
+	if (throw_error) throw std::invalid_argument("bad type");
+      }
+      return v;
+    }
+  };
+
+  template <class Type> 
+  struct traits_as<Type, pointer_category> {
+    static Type as(const octave_value& obj, bool throw_error) {
+      Type *v = 0;      
+      int res = traits_asptr<Type>::asptr(obj, &v);
+      if (SWIG_IsOK(res) && v) {
+	if (SWIG_IsNewObj(res)) {
+	  Type r(*v);
+	  %delete(v);
+	  return r;
+	} else {
+	  return *v;
+	}
+      } else {
+	// Uninitialized return value, no Type() constructor required.
+	static Type *v_def = (Type*) malloc(sizeof(Type));
+	if (!Octave_Error_Occurred()) {
+	  %type_error(swig::type_name<Type>());
+	}
+	if (throw_error) throw std::invalid_argument("bad type");
+	memset(v_def,0,sizeof(Type));
+	return *v_def;
+      }
+    }
+  };
+
+  template <class Type> 
+  struct traits_as<Type*, pointer_category> {
+    static Type* as(const octave_value& obj, bool throw_error) {
+      Type *v = 0;      
+      int res = traits_asptr<Type>::asptr(obj, &v);
+      if (SWIG_IsOK(res)) {
+	return v;
+      } else {
+	if (!Octave_Error_Occurred()) {
+	  %type_error(swig::type_name<Type>());
+	}
+	if (throw_error) throw std::invalid_argument("bad type");
+	return 0;
+      }
+    }
+  };
+    
+  template <class Type>
+  inline Type as(const octave_value& obj, bool te = false) {
+    return traits_as<Type, typename traits<Type>::category>::as(obj, te);
+  }
+
+  template <class Type> 
+  struct traits_check<Type, value_category> {
+    static bool check(const octave_value& obj) {
+      int res = asval(obj, (Type *)(0));
+      return SWIG_IsOK(res) ? true : false;
+    }
+  };
+
+  template <class Type> 
+  struct traits_check<Type, pointer_category> {
+    static bool check(const octave_value& obj) {
+      int res = asptr(obj, (Type **)(0));
+      return SWIG_IsOK(res) ? true : false;
+    }
+  };
+
+  template <class Type>
+  inline bool check(const octave_value& obj) {
+    return traits_check<Type, typename traits<Type>::category>::check(obj);
+  }
+}
+}
+
+%define %specialize_std_container(Type,Check,As,From)
+%{
+namespace swig {
+  template <>  struct traits_asval<Type > {   
+    typedef Type value_type;
+    static int asval(const octave_value& obj, value_type *val) {
+      if (Check(obj)) {
+	if (val) *val = As(obj);
+	return SWIG_OK;
+      }
+      return SWIG_ERROR;
+    }
+  };
+  template <>  struct traits_from<Type > {
+    typedef Type value_type;
+    static octave_value from(const value_type& val) {
+      return From(val);
+    }
+  };
+
+  template <> 
+  struct traits_check<Type, value_category> {
+    static int check(const octave_value& obj) {
+      int res = Check(obj);
+      return obj && res ? res : 0;
+    }
+  };
+}
+%}
+%enddef
+
+
+#define specialize_std_vector(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
+#define specialize_std_list(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
+#define specialize_std_deque(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
+#define specialize_std_set(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
+#define specialize_std_multiset(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
+
diff --git a/share/swig/3.0.12/octave/octtypemaps.swg b/share/swig/3.0.12/octave/octtypemaps.swg
new file mode 100644
index 0000000..4acf8e0
--- /dev/null
+++ b/share/swig/3.0.12/octave/octtypemaps.swg
@@ -0,0 +1,92 @@
+
+// Include fundamental fragment definitions
+%include <typemaps/fragments.swg>
+
+// Look for user fragments file.
+%include <octfragments.swg>
+
+// Octave fragments for primitive types
+%include <octprimtypes.swg>
+
+// Octave fragments for char* strings
+//%include <octstrings.swg>
+
+
+#ifndef SWIG_DIRECTOR_TYPEMAPS
+#define SWIG_DIRECTOR_TYPEMAPS
+#endif
+
+// Octave types
+#define SWIG_Object                      octave_value
+#define VOID_Object                      octave_value()
+
+/*
+// Octave allows implicit conversion
+#define %implicitconv_flag              $implicitconv 
+*/
+
+// append output
+#define SWIG_AppendOutput(result, obj)  SWIG_Octave_AppendOutput(result, obj)
+
+// set constant
+#define SWIG_SetConstant(name, obj)     SWIG_Octave_SetConstant(module_ns,name,obj) 
+
+// raise
+#define SWIG_Octave_Raise(OBJ, TYPE, DESC) error("C++ side threw an exception of type " TYPE)
+#define SWIG_Raise(obj, type, desc)     SWIG_Octave_Raise(obj, type, desc)
+
+// Include the unified typemap library
+%include <typemaps/swigtypemaps.swg>
+
+%typecheck(SWIG_TYPECHECK_SWIGOBJECT) SWIG_Object "$1 = (*$input).is_defined();";
+%typecheck(SWIG_TYPECHECK_SWIGOBJECT) octave_value_list "$1 = true;";
+
+%typemap(in) (octave_value_list varargs,...) {
+  for (int j=$argnum-1;j<args.length();++j)
+    $1.append(args(j));
+}
+%typecheck(2000) (octave_value_list varargs,...) {
+  $1=1;
+}
+
+%typemap(in) (const octave_value_list& varargs,...) (octave_value_list tmp) {
+  for (int j=$argnum-1;j<args.length();++j)
+    tmp.append(args(j));
+  $1=&tmp;
+}
+%typecheck(2000) (const octave_value_list& varargs,...) {
+  $1=1;
+}
+
+%typemap(out) octave_value_list {
+  _outp->append($1);
+}
+%typemap(out,noblock=1) octave_map, Octave_map {
+  $result=$1;
+}
+%typemap(out,noblock=1) NDArray {
+  $result=$1;
+}
+%typemap(out,noblock=1) Cell {
+  $result=$1;
+}
+
+/*
+// Smart Pointers
+%typemap(out,noblock=1) const SWIGTYPE & SMARTPOINTER  {
+  $result = SWIG_NewPointerObj(%new_copy(*$1, $*ltype), $descriptor, SWIG_POINTER_OWN | %newpointer_flags);
+}
+
+%typemap(ret) const SWIGTYPE & SMARTPOINTER, SWIGTYPE SMARTPOINTER {
+  octave_swig_type* lobj=Swig::swig_value_deref($result);
+  if (lobj) {
+    std::list<octave_value_list> idx;
+    idx.push_back(octave_value("__deref__"));
+    idx.push_back(octave_value_list());
+    octave_value_list ovl(lobj->subsref(".(",idx));
+    octave_swig_type* robj=ovl.length()>=1?Swig::swig_value_deref(ovl(0)):0;
+    if (robj && !error_state)
+      lobj->append(robj);
+  }
+}
+*/
diff --git a/share/swig/2.0.11/octave/octuserdir.swg b/share/swig/3.0.12/octave/octuserdir.swg
index ebb11b3..ebb11b3 100644
--- a/share/swig/2.0.11/octave/octuserdir.swg
+++ b/share/swig/3.0.12/octave/octuserdir.swg
diff --git a/share/swig/2.0.11/octave/std_alloc.i b/share/swig/3.0.12/octave/std_alloc.i
index 35dc051..35dc051 100644
--- a/share/swig/2.0.11/octave/std_alloc.i
+++ b/share/swig/3.0.12/octave/std_alloc.i
diff --git a/share/swig/2.0.11/octave/std_basic_string.i b/share/swig/3.0.12/octave/std_basic_string.i
index 19712e8..19712e8 100644
--- a/share/swig/2.0.11/octave/std_basic_string.i
+++ b/share/swig/3.0.12/octave/std_basic_string.i
diff --git a/share/swig/3.0.12/octave/std_carray.i b/share/swig/3.0.12/octave/std_carray.i
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/share/swig/3.0.12/octave/std_carray.i
diff --git a/share/swig/2.0.11/octave/std_char_traits.i b/share/swig/3.0.12/octave/std_char_traits.i
index bf4e6c4..bf4e6c4 100644
--- a/share/swig/2.0.11/octave/std_char_traits.i
+++ b/share/swig/3.0.12/octave/std_char_traits.i
diff --git a/share/swig/3.0.12/octave/std_common.i b/share/swig/3.0.12/octave/std_common.i
new file mode 100644
index 0000000..c8f17ba
--- /dev/null
+++ b/share/swig/3.0.12/octave/std_common.i
@@ -0,0 +1,72 @@
+%include <std/std_except.i>
+%include <octstdcommon.swg>
+
+
+// Generate the traits for a 'primitive' type, such as 'double',
+// for which the SWIG_AsVal and SWIG_From methods are already defined.
+
+%define %traits_ptypen(Type...)
+  %fragment(SWIG_Traits_frag(Type),"header",
+	    fragment=SWIG_AsVal_frag(Type),
+	    fragment=SWIG_From_frag(Type),
+	    fragment="StdTraits") {
+namespace swig {
+  template <> struct traits< Type > {
+    typedef value_category category;
+    static const char* type_name() { return  #Type; }
+  };
+  template <>  struct traits_asval< Type > {
+    typedef Type value_type;
+    static int asval(octave_value obj, value_type *val) {
+      return SWIG_AsVal(Type)(obj, val);
+    }
+  };
+  template <>  struct traits_from< Type > {
+    typedef Type value_type;
+    static octave_value from(const value_type& val) {
+      return SWIG_From(Type)(val);
+    }
+  };
+}
+}
+%enddef
+
+/* Traits for enums. This is bit of a sneaky trick needed because a generic template specialization of enums
+   is not possible (unless using template meta-programming which SWIG doesn't support because of the explicit
+   instantiations required using %template). The STL containers define the 'front' method and the typemap
+   below is used whenever the front method is wrapped returning an enum. This typemap simply picks up the
+   standard enum typemap, but additionally drags in a fragment containing the traits_asval and traits_from
+   required in the generated code for enums. */
+
+%define %traits_enum(Type...)
+  %fragment("SWIG_Traits_enum_"{Type},"header",
+	    fragment=SWIG_AsVal_frag(int),
+	    fragment=SWIG_From_frag(int),
+	    fragment="StdTraits") {
+namespace swig {
+  template <>  struct traits_asval< Type > {
+    typedef Type value_type;
+    static int asval(octave_value obj, value_type *val) {
+      return SWIG_AsVal(int)(obj, (int *)val);
+    }
+  };
+  template <>  struct traits_from< Type > {
+    typedef Type value_type;
+    static octave_value from(const value_type& val) {
+      return SWIG_From(int)((int)val);
+    }
+  };
+}
+}
+%typemap(out, fragment="SWIG_Traits_enum_"{Type}) const enum SWIGTYPE& front %{$typemap(out, const enum SWIGTYPE&)%}
+%enddef
+
+
+%include <std/std_common.i>
+
+//
+// Generates the traits for all the known primitive
+// C++ types (int, double, ...)
+//
+%apply_cpptypes(%traits_ptypen);
+
diff --git a/share/swig/2.0.11/octave/std_complex.i b/share/swig/3.0.12/octave/std_complex.i
index 771728b..771728b 100644
--- a/share/swig/2.0.11/octave/std_complex.i
+++ b/share/swig/3.0.12/octave/std_complex.i
diff --git a/share/swig/2.0.11/octave/std_container.i b/share/swig/3.0.12/octave/std_container.i
index cab7645..cab7645 100644
--- a/share/swig/2.0.11/octave/std_container.i
+++ b/share/swig/3.0.12/octave/std_container.i
diff --git a/share/swig/2.0.11/octave/std_deque.i b/share/swig/3.0.12/octave/std_deque.i
index 6866a61..6866a61 100644
--- a/share/swig/2.0.11/octave/std_deque.i
+++ b/share/swig/3.0.12/octave/std_deque.i
diff --git a/share/swig/2.0.11/python/std_except.i b/share/swig/3.0.12/octave/std_except.i
index af98428..af98428 100644
--- a/share/swig/2.0.11/python/std_except.i
+++ b/share/swig/3.0.12/octave/std_except.i
diff --git a/share/swig/2.0.11/octave/std_list.i b/share/swig/3.0.12/octave/std_list.i
index 1421efa..1421efa 100644
--- a/share/swig/2.0.11/octave/std_list.i
+++ b/share/swig/3.0.12/octave/std_list.i
diff --git a/share/swig/3.0.12/octave/std_map.i b/share/swig/3.0.12/octave/std_map.i
new file mode 100644
index 0000000..fd15661
--- /dev/null
+++ b/share/swig/3.0.12/octave/std_map.i
@@ -0,0 +1,157 @@
+// Maps
+
+%include <octcontainer.swg>
+
+%fragment("StdMapCommonTraits","header",fragment="StdSequenceTraits")
+{
+  namespace swig {
+    template <class ValueType>
+    struct from_key_oper 
+    {
+      typedef const ValueType& argument_type;
+      typedef octave_value result_type;
+      result_type operator()(argument_type v) const
+      {
+	return swig::from(v.first);
+      }
+    };
+
+    template <class ValueType>
+    struct from_value_oper 
+    {
+      typedef const ValueType& argument_type;
+      typedef octave_value result_type;
+      result_type operator()(argument_type v) const
+      {
+	return swig::from(v.second);
+      }
+    };
+
+    template<class OutIterator, class FromOper, class ValueType = typename OutIterator::value_type>
+    struct OctMapIterator_T : OctSwigIteratorClosed_T<OutIterator, ValueType, FromOper>
+    {
+      OctMapIterator_T(OutIterator curr, OutIterator first, OutIterator last, octave_value seq)
+	: OctSwigIteratorClosed_T<OutIterator,ValueType,FromOper>(curr, first, last, seq)
+      {
+      }
+    };
+
+
+    template<class OutIterator,
+	     class FromOper = from_key_oper<typename OutIterator::value_type> >
+    struct OctMapKeyIterator_T : OctMapIterator_T<OutIterator, FromOper>
+    {
+      OctMapKeyIterator_T(OutIterator curr, OutIterator first, OutIterator last, octave_value seq)
+	: OctMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
+      {
+      }
+    };
+
+    template<typename OutIter>
+    inline OctSwigIterator*
+    make_output_key_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, octave_value seq = octave_value())
+    {
+      return new OctMapKeyIterator_T<OutIter>(current, begin, end, seq);
+    }
+
+    template<class OutIterator,
+	     class FromOper = from_value_oper<typename OutIterator::value_type> >
+    struct OctMapValueIterator_T : OctMapIterator_T<OutIterator, FromOper>
+    {
+      OctMapValueIterator_T(OutIterator curr, OutIterator first, OutIterator last, octave_value seq)
+	: OctMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
+      {
+      }
+    };
+    
+
+    template<typename OutIter>
+    inline OctSwigIterator*
+    make_output_value_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, octave_value seq = 0)
+    {
+      return new OctMapValueIterator_T<OutIter>(current, begin, end, seq);
+    }
+  }
+}
+
+%fragment("StdMapTraits","header",fragment="StdMapCommonTraits")
+{
+  namespace swig {
+    template <class OctSeq, class K, class T >
+    inline void
+    assign(const OctSeq& octseq, std::map<K,T > *map) {
+      typedef typename std::map<K,T>::value_type value_type;
+      typename OctSeq::const_iterator it = octseq.begin();
+      for (;it != octseq.end(); ++it) {
+	map->insert(value_type(it->first, it->second));
+      }
+    }
+
+    template <class K, class T>
+    struct traits_asptr<std::map<K,T> >  {
+      typedef std::map<K,T> map_type;
+      static int asptr(octave_value obj, map_type **val) {
+	/*
+	int res = SWIG_ERROR;
+	if (PyDict_Check(obj)) {
+	  SwigVar_PyObject items = PyObject_CallMethod(obj,(char *)"items",NULL);
+	  res = traits_asptr_stdseq<std::map<K,T>, std::pair<K, T> >::asptr(items, val);
+	} else {
+	  map_type *p;
+	  swig_type_info *descriptor = swig::type_info<map_type>();
+	  res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
+	  if (SWIG_IsOK(res) && val)  *val = p;
+	}
+	return res;
+	*/
+	return SWIG_ERROR;
+      }      
+    };
+      
+    template <class K, class T >
+    struct traits_from<std::map<K,T> >  {
+      typedef std::map<K,T> map_type;
+      typedef typename map_type::const_iterator const_iterator;
+      typedef typename map_type::size_type size_type;
+            
+      static octave_value from(const map_type& map) {
+	/*
+	swig_type_info *desc = swig::type_info<map_type>();
+	if (desc && desc->clientdata) {
+	  return SWIG_NewPointerObj(new map_type(map), desc, SWIG_POINTER_OWN);
+	} else {
+	  size_type size = map.size();
+	  int pysize = (size <= (size_type) INT_MAX) ? (int) size : -1;
+	  if (pysize < 0) {
+	    SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+	    PyErr_SetString(PyExc_OverflowError,
+			    "map size not valid in python");
+	    SWIG_PYTHON_THREAD_END_BLOCK;
+	    return NULL;
+	  }
+	  PyObject *obj = PyDict_New();
+	  for (const_iterator i= map.begin(); i!= map.end(); ++i) {
+	    swig::SwigVar_PyObject key = swig::from(i->first);
+	    swig::SwigVar_PyObject val = swig::from(i->second);
+	    PyDict_SetItem(obj, key, val);
+	  }
+	  return obj;
+	}
+	*/
+	return octave_value();
+      }
+    };
+  }
+}
+
+%define %swig_map_common(Map...)
+  %swig_sequence_iterator(Map);
+  %swig_container_methods(Map);
+%enddef
+
+%define %swig_map_methods(Map...)
+     %swig_map_common(Map)
+%enddef
+
+
+%include <std/std_map.i>
diff --git a/share/swig/3.0.12/octave/std_pair.i b/share/swig/3.0.12/octave/std_pair.i
new file mode 100644
index 0000000..2f3d4df
--- /dev/null
+++ b/share/swig/3.0.12/octave/std_pair.i
@@ -0,0 +1,135 @@
+// Pairs
+
+%include <octstdcommon.swg>
+
+//#define SWIG_STD_PAIR_ASVAL
+
+%fragment("StdPairTraits","header",fragment="StdTraits") {
+  namespace swig {
+#ifdef SWIG_STD_PAIR_ASVAL
+    template <class T, class U >
+    struct traits_asval<std::pair<T,U> >  {
+      typedef std::pair<T,U> value_type;
+
+      static int get_pair(const octave_value& first, octave_value second,
+			  std::pair<T,U> *val)
+      {
+	if (val) {
+	  T *pfirst = &(val->first);
+	  int res1 = swig::asval(first, pfirst);
+	  if (!SWIG_IsOK(res1))
+	    return res1;
+	  U *psecond = &(val->second);
+	  int res2 = swig::asval(second, psecond);
+	  if (!SWIG_IsOK(res2))
+	    return res2;
+	  return res1 > res2 ? res1 : res2;
+	} else {
+	  T *pfirst = 0;
+	  int res1 = swig::asval(first, pfirst);
+	  if (!SWIG_IsOK(res1))
+	    return res1;
+	  U *psecond = 0;
+	  int res2 = swig::asval((PyObject*)second, psecond);
+	  if (!SWIG_IsOK(res2))
+	    return res2;
+	  return res1 > res2 ? res1 : res2;
+	}
+      }
+
+      static int asval(const octave_value& obj, std::pair<T,U> *val) {
+	if (obj.is_cell()) {
+	  Cell c=obj.cell_value();
+	  if (c.numel()<2) {
+	    error("pair from Cell array requires at least two elements");
+	    return SWIG_ERROR;
+	  }
+	  return get_pair(c(0),c(1),val);
+	} else {
+	  value_type *p;
+	  swig_type_info *descriptor = swig::type_info<value_type>();
+	  int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
+	  if (SWIG_IsOK(res) && val)
+	    *val = *p;
+	  return res;
+	}
+	return SWIG_ERROR;
+      }
+    };
+
+#else
+    template <class T, class U >
+    struct traits_asptr<std::pair<T,U> >  {
+      typedef std::pair<T,U> value_type;
+
+      static int get_pair(const octave_value& first, octave_value second,
+			  std::pair<T,U> **val) 
+      {
+	if (val) {
+	  value_type *vp = %new_instance(std::pair<T,U>);
+	  T *pfirst = &(vp->first);
+	  int res1 = swig::asval(first, pfirst);
+	  if (!SWIG_IsOK(res1)) {
+	    %delete(vp);
+	    return res1;
+	  }
+	  U *psecond = &(vp->second);
+	  int res2 = swig::asval(second, psecond);
+	  if (!SWIG_IsOK(res2)) {
+	    %delete(vp);
+	    return res2;
+	  }
+	  *val = vp;
+	  return SWIG_AddNewMask(res1 > res2 ? res1 : res2);
+	} else {
+	  T *pfirst = 0;
+	  int res1 = swig::asval(first, pfirst);
+	  if (!SWIG_IsOK(res1))
+	    return res1;
+	  U *psecond = 0;
+	  int res2 = swig::asval(second, psecond);
+	  if (!SWIG_IsOK(res2))
+	    return res2;
+	  return res1 > res2 ? res1 : res2;
+	}
+	return SWIG_ERROR;
+      }
+
+      static int asptr(const octave_value& obj, std::pair<T,U> **val) {
+	if (obj.is_cell()) {
+	  Cell c=obj.cell_value();
+	  if (c.numel()<2) {
+	    error("pair from Cell array requires at least two elements");
+	    return SWIG_ERROR;
+	  }
+	  return get_pair(c(0),c(1),val);
+	} else {
+	  value_type *p;
+	  swig_type_info *descriptor = swig::type_info<value_type>();
+	  int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
+	  if (SWIG_IsOK(res) && val)
+	    *val = p;
+	  return res;
+	}
+	return SWIG_ERROR;
+      }
+    };
+
+#endif
+    template <class T, class U >
+    struct traits_from<std::pair<T,U> >   {
+      static octave_value from(const std::pair<T,U>& val) {
+	Cell c(1,2);
+	c(0)=swig::from(val.first);
+	c(1)=swig::from(val.second);
+	return c;
+      }
+    };
+  }
+}
+
+%define %swig_pair_methods(pair...)
+%enddef
+
+%include <std/std_pair.i>
+
diff --git a/share/swig/2.0.11/python/std_shared_ptr.i b/share/swig/3.0.12/octave/std_shared_ptr.i
index df87367..df87367 100644
--- a/share/swig/2.0.11/python/std_shared_ptr.i
+++ b/share/swig/3.0.12/octave/std_shared_ptr.i
diff --git a/share/swig/2.0.11/r/std_string.i b/share/swig/3.0.12/octave/std_string.i
index dc1378a..dc1378a 100644
--- a/share/swig/2.0.11/r/std_string.i
+++ b/share/swig/3.0.12/octave/std_string.i
diff --git a/share/swig/2.0.11/octave/std_vector.i b/share/swig/3.0.12/octave/std_vector.i
index 2862b5e..2862b5e 100644
--- a/share/swig/2.0.11/octave/std_vector.i
+++ b/share/swig/3.0.12/octave/std_vector.i
diff --git a/share/swig/3.0.12/octave/std_wstring.i b/share/swig/3.0.12/octave/std_wstring.i
new file mode 100644
index 0000000..dc1378a
--- /dev/null
+++ b/share/swig/3.0.12/octave/std_wstring.i
@@ -0,0 +1 @@
+%include <typemaps/std_string.swg>
diff --git a/share/swig/2.0.11/octave/stl.i b/share/swig/3.0.12/octave/stl.i
index b29f7d8..b29f7d8 100644
--- a/share/swig/2.0.11/octave/stl.i
+++ b/share/swig/3.0.12/octave/stl.i
diff --git a/share/swig/2.0.11/octave/typemaps.i b/share/swig/3.0.12/octave/typemaps.i
index 1f9b9c4..1f9b9c4 100644
--- a/share/swig/2.0.11/octave/typemaps.i
+++ b/share/swig/3.0.12/octave/typemaps.i
diff --git a/share/swig/3.0.12/perl5/Makefile.pl b/share/swig/3.0.12/perl5/Makefile.pl
new file mode 100644
index 0000000..cffdc8e
--- /dev/null
+++ b/share/swig/3.0.12/perl5/Makefile.pl
@@ -0,0 +1,19 @@
+# File : Makefile.pl
+# MakeMaker file for a SWIG module.  Use this file if you are
+# producing a module for general use or distribution.
+#
+# 1.  Modify the file as appropriate. Replace $module with the
+#     real name of your module and wrapper file.
+# 2.  Run perl as 'perl Makefile.pl'
+# 3.  Type 'make' to build your module
+# 4.  Type 'make install' to install your module.
+#
+# See "Programming Perl", 2nd. Ed, for more gory details than
+# you ever wanted to know.
+
+use ExtUtils::MakeMaker;
+WriteMakefile(
+     'NAME' => '$module',            # Name of your module
+     'LIBS' => [''],                 # Custom libraries (if any)
+     'OBJECT' => '$module_wrap.o'    # Object files
+);
diff --git a/share/swig/2.0.11/perl5/attribute.i b/share/swig/3.0.12/perl5/attribute.i
index 779716c..779716c 100644
--- a/share/swig/2.0.11/perl5/attribute.i
+++ b/share/swig/3.0.12/perl5/attribute.i
diff --git a/share/swig/2.0.11/perl5/carrays.i b/share/swig/3.0.12/perl5/carrays.i
index 8be67ab..8be67ab 100644
--- a/share/swig/2.0.11/perl5/carrays.i
+++ b/share/swig/3.0.12/perl5/carrays.i
diff --git a/share/swig/2.0.11/r/cdata.i b/share/swig/3.0.12/perl5/cdata.i
index 3679659..3679659 100644
--- a/share/swig/2.0.11/r/cdata.i
+++ b/share/swig/3.0.12/perl5/cdata.i
diff --git a/share/swig/2.0.11/perl5/cmalloc.i b/share/swig/3.0.12/perl5/cmalloc.i
index 248f06b..248f06b 100644
--- a/share/swig/2.0.11/perl5/cmalloc.i
+++ b/share/swig/3.0.12/perl5/cmalloc.i
diff --git a/share/swig/2.0.11/perl5/cni.i b/share/swig/3.0.12/perl5/cni.i
index c4d4eaf..c4d4eaf 100644
--- a/share/swig/2.0.11/perl5/cni.i
+++ b/share/swig/3.0.12/perl5/cni.i
diff --git a/share/swig/2.0.11/perl5/cpointer.i b/share/swig/3.0.12/perl5/cpointer.i
index d824792..d824792 100644
--- a/share/swig/2.0.11/perl5/cpointer.i
+++ b/share/swig/3.0.12/perl5/cpointer.i
diff --git a/share/swig/2.0.11/perl5/cstring.i b/share/swig/3.0.12/perl5/cstring.i
index ede9c59..ede9c59 100644
--- a/share/swig/2.0.11/perl5/cstring.i
+++ b/share/swig/3.0.12/perl5/cstring.i
diff --git a/share/swig/3.0.12/perl5/director.swg b/share/swig/3.0.12/perl5/director.swg
new file mode 100644
index 0000000..f0a6614
--- /dev/null
+++ b/share/swig/3.0.12/perl5/director.swg
@@ -0,0 +1,317 @@
+/* -----------------------------------------------------------------------------
+ * director.swg
+ *
+ * This file contains support for director classes so that Perl proxy
+ * methods can be called from C++.
+ * ----------------------------------------------------------------------------- */
+
+#ifndef SWIG_DIRECTOR_PERL_HEADER_
+#define SWIG_DIRECTOR_PERL_HEADER_
+
+#include <string>
+#include <iostream>
+#include <exception>
+#include <vector>
+#include <map>
+
+
+/*
+  Use -DSWIG_DIRECTOR_NORTTI if you prefer to avoid the use of the
+  native C++ RTTI and dynamic_cast<>. But be aware that directors
+  could stop working when using this option.
+*/
+#ifdef SWIG_DIRECTOR_NORTTI
+/*
+   When we don't use the native C++ RTTI, we implement a minimal one
+   only for Directors.
+*/
+# ifndef SWIG_DIRECTOR_RTDIR
+# define SWIG_DIRECTOR_RTDIR
+
+namespace Swig {
+  class Director;
+  SWIGINTERN std::map<void *, Director *>& get_rtdir_map() {
+    static std::map<void *, Director *> rtdir_map;
+    return rtdir_map;
+  }
+
+  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *rtdir) {
+    get_rtdir_map()[vptr] = rtdir;
+  }
+
+  SWIGINTERNINLINE Director *get_rtdir(void *vptr) {
+    std::map<void *, Director *>::const_iterator pos = get_rtdir_map().find(vptr);
+    Director *rtdir = (pos != get_rtdir_map().end()) ? pos->second : 0;
+    return rtdir;
+  }
+}
+# endif /* SWIG_DIRECTOR_RTDIR */
+
+# define SWIG_DIRECTOR_CAST(ARG) Swig::get_rtdir(static_cast<void *>(ARG))
+# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) Swig::set_rtdir(static_cast<void *>(ARG1), ARG2)
+
+#else
+
+# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG)
+# define SWIG_DIRECTOR_RGTR(ARG1, ARG2)
+
+#endif /* SWIG_DIRECTOR_NORTTI */
+
+extern "C" {
+  struct swig_type_info;
+}
+
+namespace Swig {
+
+  /* memory handler */
+  struct GCItem {
+    virtual ~GCItem() {}
+
+    virtual int get_own() const {
+      return 0;
+    }
+  };
+
+  struct GCItem_var {
+    GCItem_var(GCItem *item = 0) : _item(item) {
+    }
+
+    GCItem_var& operator=(GCItem *item) {
+      GCItem *tmp = _item;
+      _item = item;
+      delete tmp;
+      return *this;
+    }
+
+    ~GCItem_var() {
+      delete _item;
+    }
+
+    GCItem *operator->() const {
+      return _item;
+    }
+
+  private:
+    GCItem *_item;
+  };
+
+  struct GCItem_Object : GCItem {
+    GCItem_Object(int own) : _own(own) {
+    }
+
+    virtual ~GCItem_Object() {
+    }
+
+    int get_own() const {
+      return _own;
+    }
+
+  private:
+    int _own;
+  };
+
+  template <typename Type>
+  struct GCItem_T : GCItem {
+    GCItem_T(Type *ptr) : _ptr(ptr) {
+    }
+
+    virtual ~GCItem_T() {
+      delete _ptr;
+    }
+
+  private:
+    Type *_ptr;
+  };
+
+  template <typename Type>
+  struct GCArray_T : GCItem {
+    GCArray_T(Type *ptr) : _ptr(ptr) {
+    }
+
+    virtual ~GCArray_T() {
+      delete[] _ptr;
+    }
+
+  private:
+    Type *_ptr;
+  };
+
+  /* base class for director exceptions */
+  class DirectorException : public std::exception {
+  public:
+    virtual SV *getNative() const = 0;
+  };
+
+  /* exceptions emitted by Perl */
+  class DirectorMethodException : public DirectorException {
+  protected:
+    SV *err;
+  public:
+    DirectorMethodException(SV *sv = sv_mortalcopy(ERRSV)) : err(sv) {
+      SvREFCNT_inc(err);
+    }
+
+    const char *what() const throw() {
+      return SvPV_nolen(err);
+    }
+
+    SV *getNative() const {
+      return sv_2mortal(newSVsv(err));
+    }
+
+    static void raise(SV *sv) {
+      throw DirectorMethodException(sv);
+    }
+  };
+
+  /* exceptions emitted by wrap code */
+  class DirectorWrapException : public DirectorException {
+  protected:
+    std::string msg;
+    DirectorWrapException(const char *str) : msg(str) {
+    }
+
+  public:
+    virtual ~DirectorWrapException() throw() {
+    }
+
+    const char *what() const throw() {
+      return msg.c_str();
+    }
+
+    virtual SV *getNative() const {
+      return sv_2mortal(newSVpvn(msg.data(), msg.size()));
+    }
+  };
+
+  class DirectorTypeMismatchException : public DirectorWrapException {
+  public:
+    DirectorTypeMismatchException(const char *str) : DirectorWrapException(str) {
+    }
+
+    static void raise(const char *type, const char *msg) {
+      std::string err = std::string(type);
+      err += ": ";
+      err += msg;
+      throw DirectorTypeMismatchException(err.c_str());
+    }
+  };
+
+  class DirectorPureVirtualException : public DirectorWrapException {
+  public:
+    DirectorPureVirtualException(const char *name)
+      : DirectorWrapException("SWIG director pure virtual method called: ") {
+      msg += name;
+    }
+
+    static void raise(const char *name) {
+      throw DirectorPureVirtualException(name);
+    }
+  };
+
+  /* director base class */
+  class Director {
+  private:
+    /* pointer to the wrapped perl object */
+    SV *swig_self;
+    /* class of wrapped perl object */
+    std::string swig_class;
+    /* flag indicating whether the object is owned by perl or c++ */
+    mutable bool swig_disown_flag;
+
+    /* decrement the reference count of the wrapped perl object */
+    void swig_decref() const {
+      if (swig_disown_flag) {
+        SvREFCNT_dec(swig_self);
+      }
+    }
+
+  public:
+    /* wrap a Perl object. */
+    Director(SV *pkg) : swig_disown_flag(false) {
+      STRLEN len;
+      char *str = SvPV(pkg, len);
+      swig_class = std::string(str, len);
+      swig_self = newRV_inc((SV *)newHV());
+    }
+
+    /* discard our reference at destruction */
+    virtual ~Director() {
+      swig_decref();
+    }
+
+    /* return a pointer to the wrapped Perl object */
+    SV *swig_get_self() const {
+      return swig_self;
+    }
+
+    const char *swig_get_class() const {
+      return swig_class.c_str();
+    }
+
+    /* acquire ownership of the wrapped Perl object (the sense of "disown" is from perl) */
+    void swig_disown() const {
+      if (!swig_disown_flag) {
+        swig_disown_flag=true;
+        swig_incref();
+      }
+    }
+
+    /* increase the reference count of the wrapped Perl object */
+    void swig_incref() const {
+      if (swig_disown_flag) {
+        SvREFCNT_inc(swig_self);
+      }
+    }
+
+    /* methods to implement pseudo protected director members */
+    virtual bool swig_get_inner(const char * /* swig_protected_method_name */) const {
+      return true;
+    }
+
+    virtual void swig_set_inner(const char * /* swig_protected_method_name */, bool /* swig_val */) const {
+    }
+
+  /* ownership management */
+  private:
+    typedef std::map<void *, GCItem_var> swig_ownership_map;
+    mutable swig_ownership_map swig_owner;
+
+  public:
+    template <typename Type>
+    void swig_acquire_ownership_array(Type *vptr) const {
+      if (vptr) {
+        swig_owner[vptr] = new GCArray_T<Type>(vptr);
+      }
+    }
+
+    template <typename Type>
+    void swig_acquire_ownership(Type *vptr) const {
+      if (vptr) {
+        swig_owner[vptr] = new GCItem_T<Type>(vptr);
+      }
+    }
+
+    void swig_acquire_ownership_obj(void *vptr, int own) const {
+      if (vptr && own) {
+        swig_owner[vptr] = new GCItem_Object(own);
+      }
+    }
+
+    int swig_release_ownership(void *vptr) const {
+      int own = 0;
+      if (vptr) {
+        swig_ownership_map::iterator iter = swig_owner.find(vptr);
+        if (iter != swig_owner.end()) {
+          own = iter->second->get_own();
+          swig_owner.erase(iter);
+        }
+      }
+      return own;
+    }
+  };
+
+}
+
+#endif
+
diff --git a/share/swig/2.0.11/perl5/exception.i b/share/swig/3.0.12/perl5/exception.i
index b786f25..b786f25 100644
--- a/share/swig/2.0.11/perl5/exception.i
+++ b/share/swig/3.0.12/perl5/exception.i
diff --git a/share/swig/2.0.11/perl5/factory.i b/share/swig/3.0.12/perl5/factory.i
index 46a0a87..46a0a87 100644
--- a/share/swig/2.0.11/perl5/factory.i
+++ b/share/swig/3.0.12/perl5/factory.i
diff --git a/share/swig/2.0.11/perl5/jstring.i b/share/swig/3.0.12/perl5/jstring.i
index 1c179b7..1c179b7 100644
--- a/share/swig/2.0.11/perl5/jstring.i
+++ b/share/swig/3.0.12/perl5/jstring.i
diff --git a/share/swig/3.0.12/perl5/noembed.h b/share/swig/3.0.12/perl5/noembed.h
new file mode 100644
index 0000000..4e30f11
--- /dev/null
+++ b/share/swig/3.0.12/perl5/noembed.h
@@ -0,0 +1,116 @@
+/* Workaround perl5 global namespace pollution. Note that undefining library
+ * functions like fopen will not solve the problem on all platforms as fopen
+ * might be a macro on Windows but not necessarily on other operating systems. */
+#ifdef do_open
+  #undef do_open
+#endif
+#ifdef do_close
+  #undef do_close
+#endif
+#ifdef do_exec
+  #undef do_exec
+#endif
+#ifdef scalar
+  #undef scalar
+#endif
+#ifdef list
+  #undef list
+#endif
+#ifdef apply
+  #undef apply
+#endif
+#ifdef convert
+  #undef convert
+#endif
+#ifdef Error
+  #undef Error
+#endif
+#ifdef form
+  #undef form
+#endif
+#ifdef vform
+  #undef vform
+#endif
+#ifdef LABEL
+  #undef LABEL
+#endif
+#ifdef METHOD
+  #undef METHOD
+#endif
+#ifdef Move
+  #undef Move
+#endif
+#ifdef yylex
+  #undef yylex
+#endif
+#ifdef yyparse
+  #undef yyparse
+#endif
+#ifdef yyerror
+  #undef yyerror
+#endif
+#ifdef invert
+  #undef invert
+#endif
+#ifdef ref
+  #undef ref
+#endif
+#ifdef read
+  #undef read
+#endif
+#ifdef write
+  #undef write
+#endif
+#ifdef eof
+  #undef eof
+#endif
+#ifdef close
+  #undef close
+#endif
+#ifdef rewind
+  #undef rewind
+#endif
+#ifdef free
+  #undef free
+#endif
+#ifdef malloc
+  #undef malloc
+#endif
+#ifdef calloc
+  #undef calloc
+#endif
+#ifdef Stat
+  #undef Stat
+#endif
+#ifdef check
+  #undef check
+#endif
+#ifdef seekdir
+  #undef seekdir
+#endif
+#ifdef open
+  #undef open
+#endif
+#ifdef readdir
+  #undef readdir
+#endif
+#ifdef bind
+  #undef bind
+#endif
+#ifdef access
+  #undef access
+#endif
+#ifdef stat
+  #undef stat
+#endif
+#ifdef seed
+  #undef seed
+#endif
+
+#ifdef bool
+  /* Leave if macro is from C99 stdbool.h */
+  #ifndef __bool_true_false_are_defined
+    #undef bool
+  #endif
+#endif
+
diff --git a/share/swig/2.0.11/perl5/perl5.swg b/share/swig/3.0.12/perl5/perl5.swg
index 693c2b9..693c2b9 100644
--- a/share/swig/2.0.11/perl5/perl5.swg
+++ b/share/swig/3.0.12/perl5/perl5.swg
diff --git a/share/swig/2.0.11/perl5/perlerrors.swg b/share/swig/3.0.12/perl5/perlerrors.swg
index 57296c6..57296c6 100644
--- a/share/swig/2.0.11/perl5/perlerrors.swg
+++ b/share/swig/3.0.12/perl5/perlerrors.swg
diff --git a/share/swig/2.0.11/perl5/perlfragments.swg b/share/swig/3.0.12/perl5/perlfragments.swg
index 45d25d1..45d25d1 100644
--- a/share/swig/2.0.11/perl5/perlfragments.swg
+++ b/share/swig/3.0.12/perl5/perlfragments.swg
diff --git a/share/swig/2.0.11/perl5/perlhead.swg b/share/swig/3.0.12/perl5/perlhead.swg
index 5437af5..5437af5 100644
--- a/share/swig/2.0.11/perl5/perlhead.swg
+++ b/share/swig/3.0.12/perl5/perlhead.swg
diff --git a/share/swig/3.0.12/perl5/perlinit.swg b/share/swig/3.0.12/perl5/perlinit.swg
new file mode 100644
index 0000000..b49040d
--- /dev/null
+++ b/share/swig/3.0.12/perl5/perlinit.swg
@@ -0,0 +1,82 @@
+
+/* Export the SWIG initialization function */
+%header %{
+#ifdef __cplusplus
+extern "C"
+#endif
+#ifndef PERL_OBJECT
+#ifndef MULTIPLICITY
+SWIGEXPORT void SWIG_init (CV* cv);
+#else
+SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
+#endif
+#else
+SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
+#endif
+%}
+
+/* Module initialization function */
+
+%insert(init) "swiginit.swg"
+
+%init %{
+
+#if defined(__cplusplus) && ! defined(XSPROTO)
+extern "C"
+#endif
+
+XS(SWIG_init) {
+    dXSARGS;
+    int i;
+    (void)items;
+
+    SWIG_InitializeModule(0);
+
+    /* Install commands */
+    for (i = 0; swig_commands[i].name; i++) {
+      /* Casts only needed for Perl < 5.10. */
+#ifdef __cplusplus
+      newXS(const_cast<char*>(swig_commands[i].name), swig_commands[i].wrapper, const_cast<char*>(__FILE__));
+#else
+      newXS((char*)swig_commands[i].name, swig_commands[i].wrapper, (char*)__FILE__);
+#endif
+    }
+
+    /* Install variables */
+    for (i = 0; swig_variables[i].name; i++) {
+      SV *sv;
+      sv = get_sv(swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
+      if (swig_variables[i].type) {
+	SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
+      } else {
+	sv_setiv(sv,(IV) 0);
+      }
+      swig_create_magic(sv, swig_variables[i].name, swig_variables[i].set, swig_variables[i].get); 
+    }
+
+    /* Install constant */
+    for (i = 0; swig_constants[i].type; i++) {
+      SV *sv;
+      sv = get_sv(swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
+      switch(swig_constants[i].type) {
+      case SWIG_INT:
+	sv_setiv(sv, (IV) swig_constants[i].lvalue);
+	break;
+      case SWIG_FLOAT:
+	sv_setnv(sv, (double) swig_constants[i].dvalue);
+	break;
+      case SWIG_STRING:
+	sv_setpv(sv, (const char *) swig_constants[i].pvalue);
+	break;
+      case SWIG_POINTER:
+	SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
+	break;
+      case SWIG_BINARY:
+	SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
+	break;
+      default:
+	break;
+      }
+      SvREADONLY_on(sv);
+    }
+%}
diff --git a/share/swig/2.0.11/perl5/perlkw.swg b/share/swig/3.0.12/perl5/perlkw.swg
index 00648e0..00648e0 100644
--- a/share/swig/2.0.11/perl5/perlkw.swg
+++ b/share/swig/3.0.12/perl5/perlkw.swg
diff --git a/share/swig/2.0.11/perl5/perlmacros.swg b/share/swig/3.0.12/perl5/perlmacros.swg
index 4917f6e..4917f6e 100644
--- a/share/swig/2.0.11/perl5/perlmacros.swg
+++ b/share/swig/3.0.12/perl5/perlmacros.swg
diff --git a/share/swig/2.0.11/perl5/perlmain.i b/share/swig/3.0.12/perl5/perlmain.i
index 18ecb7e..18ecb7e 100644
--- a/share/swig/2.0.11/perl5/perlmain.i
+++ b/share/swig/3.0.12/perl5/perlmain.i
diff --git a/share/swig/2.0.11/perl5/perlopers.swg b/share/swig/3.0.12/perl5/perlopers.swg
index e7d13b6..e7d13b6 100644
--- a/share/swig/2.0.11/perl5/perlopers.swg
+++ b/share/swig/3.0.12/perl5/perlopers.swg
diff --git a/share/swig/3.0.12/perl5/perlprimtypes.swg b/share/swig/3.0.12/perl5/perlprimtypes.swg
new file mode 100644
index 0000000..4cb6756
--- /dev/null
+++ b/share/swig/3.0.12/perl5/perlprimtypes.swg
@@ -0,0 +1,364 @@
+/* ------------------------------------------------------------
+ * Primitive Types
+ * ------------------------------------------------------------ */
+
+/* bool */
+
+%fragment(SWIG_From_frag(bool),"header") {
+SWIGINTERNINLINE SV *
+SWIG_From_dec(bool)(bool value)
+{
+  return boolSV(value);
+}
+}
+
+%fragment(SWIG_AsVal_frag(bool),"header") {
+SWIGINTERN int
+SWIG_AsVal_dec(bool)(SV *obj, bool* val)
+{
+  if (obj == &PL_sv_yes) {
+    if (val) *val = true;
+    return SWIG_OK;
+  } else if (obj == &PL_sv_no) { 
+    if (val) *val = false;
+    return SWIG_OK;
+  } else {
+    if (val) *val = SvTRUE(obj) ? true : false;
+    return SWIG_AddCast(SWIG_OK);    
+  }
+}
+}
+
+
+/* long */
+
+%fragment(SWIG_From_frag(long),"header") {
+SWIGINTERNINLINE SV *
+SWIG_From_dec(long)(long value)
+{
+  SV *sv;
+  if (IVSIZE >= sizeof(value) || (value >= IV_MIN && value <= IV_MAX))
+    sv = newSViv(value);
+  else
+    sv = newSVpvf("%ld", value);
+  return sv_2mortal(sv);
+}
+}
+
+%fragment(SWIG_AsVal_frag(long),"header",
+	  fragment="<limits.h>",
+	  fragment="<stdlib.h>",
+	  fragment="SWIG_CanCastAsInteger") {
+SWIGINTERN int
+SWIG_AsVal_dec(long)(SV *obj, long* val)
+{
+  if (SvUOK(obj)) {
+    UV v = SvUV(obj);
+    if (UVSIZE < sizeof(*val) || v <= LONG_MAX) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+    return SWIG_OverflowError;
+  } else if (SvIOK(obj)) {
+    IV v = SvIV(obj);
+    if (IVSIZE <= sizeof(*val) || (v >= LONG_MIN && v <= LONG_MAX)) {
+      if(val) *val = v;
+      return SWIG_OK;
+    }
+    return SWIG_OverflowError;
+  } else {
+    int dispatch = 0;
+    const char *nptr = SvPV_nolen(obj);
+    if (nptr) {
+      char *endptr;
+      long v;
+      errno = 0;
+      v = strtol(nptr, &endptr,0);
+      if (errno == ERANGE) {
+	errno = 0;
+	return SWIG_OverflowError;
+      } else {
+	if (*endptr == '\0') {
+	  if (val) *val = v;
+	  return SWIG_Str2NumCast(SWIG_OK);
+	}
+      }
+    }
+    if (!dispatch) {
+      double d;
+      int res = SWIG_AddCast(SWIG_AsVal(double)(obj,&d));
+      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
+	if (val) *val = (long)(d);
+	return res;
+      }
+    }
+  }
+  return SWIG_TypeError;
+}
+}
+
+/* unsigned long */
+
+%fragment(SWIG_From_frag(unsigned long),"header") {
+SWIGINTERNINLINE SV *
+SWIG_From_dec(unsigned long)(unsigned long value)
+{
+  SV *sv;
+  if (UVSIZE >= sizeof(value) || value <= UV_MAX)
+    sv = newSVuv(value);
+  else
+    sv = newSVpvf("%lu", value);
+  return sv_2mortal(sv);
+}
+}
+
+%fragment(SWIG_AsVal_frag(unsigned long),"header",
+	  fragment="<limits.h>",
+	  fragment="<stdlib.h>",
+	  fragment="SWIG_CanCastAsInteger") {
+SWIGINTERN int
+SWIG_AsVal_dec(unsigned long)(SV *obj, unsigned long *val) 
+{
+  if (SvUOK(obj)) {
+    UV v = SvUV(obj);
+    if (UVSIZE <= sizeof(*val) || v <= ULONG_MAX) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+    return SWIG_OverflowError;
+  } else if (SvIOK(obj)) {
+    IV v = SvIV(obj);
+    if (v >= 0 && (IVSIZE <= sizeof(*val) || v <= ULONG_MAX)) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+    return SWIG_OverflowError;
+  } else {
+    int dispatch = 0;
+    const char *nptr = SvPV_nolen(obj);
+    if (nptr) {
+      char *endptr;
+      unsigned long v;
+      errno = 0;
+      v = strtoul(nptr, &endptr,0);
+      if (errno == ERANGE) {
+	errno = 0;
+	return SWIG_OverflowError;
+      } else {
+	if (*endptr == '\0') {
+	  if (val) *val = v;
+	  return SWIG_Str2NumCast(SWIG_OK);
+	}
+      }
+    }
+    if (!dispatch) {
+      double d;
+      int res = SWIG_AddCast(SWIG_AsVal(double)(obj,&d));
+      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
+	if (val) *val = (unsigned long)(d);
+	return res;
+      }
+    }
+  }
+  return SWIG_TypeError;
+}
+}
+
+/* long long */
+
+%fragment(SWIG_From_frag(long long),"header",
+	  fragment="SWIG_LongLongAvailable",
+	  fragment="<stdio.h>") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERNINLINE SV *
+SWIG_From_dec(long long)(long long value)
+{
+  SV *sv;
+  if (IVSIZE >= sizeof(value) || (value >= IV_MIN && value <= IV_MAX))
+    sv = newSViv((IV)(value));
+  else {
+    //sv = newSVpvf("%lld", value); doesn't work in non 64bit Perl
+    char temp[256];
+    sprintf(temp, "%lld", value);
+    sv = newSVpv(temp, 0);
+  }
+  return sv_2mortal(sv);
+}
+%#endif
+}
+
+%fragment(SWIG_AsVal_frag(long long),"header",
+	  fragment="SWIG_LongLongAvailable",
+	  fragment="<stdlib.h>",
+	  fragment="SWIG_CanCastAsInteger") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERN int
+SWIG_AsVal_dec(long long)(SV *obj, long long *val)
+{
+  if (SvUOK(obj)) {
+    UV v = SvUV(obj);
+    /* pretty sure this could allow v == LLONG MAX */
+    if (UVSIZE < sizeof(*val) || v < LLONG_MAX) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+    return SWIG_OverflowError;
+  } else if (SvIOK(obj)) {
+    IV v = SvIV(obj);
+    if (IVSIZE <= sizeof(*val) || (v >= LLONG_MIN && v <= LLONG_MAX)) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+    return SWIG_OverflowError;
+  } else {
+    int dispatch = 0;
+    const char *nptr = SvPV_nolen(obj);
+    if (nptr) {
+      char *endptr;
+      long long v;
+      errno = 0;
+      v = strtoll(nptr, &endptr,0);
+      if (errno == ERANGE) {
+	errno = 0;
+	return SWIG_OverflowError;
+      } else {
+	if (*endptr == '\0') {
+	  if (val) *val = v;
+	  return SWIG_Str2NumCast(SWIG_OK);
+	}
+      }
+    }
+    if (!dispatch) {
+      const double mant_max = 1LL << DBL_MANT_DIG;
+      const double mant_min = -mant_max;
+      double d;
+      int res = SWIG_AddCast(SWIG_AsVal(double)(obj,&d));
+      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
+	if (val) *val = (long long)(d);
+	return res;
+      }
+    }
+  }
+  return SWIG_TypeError; 
+}
+%#endif
+}
+
+/* unsigned long long */
+
+%fragment(SWIG_From_frag(unsigned long long),"header",
+	  fragment="SWIG_LongLongAvailable",
+	  fragment="<stdio.h>") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERNINLINE SV *
+SWIG_From_dec(unsigned long long)(unsigned long long value)
+{
+  SV *sv;
+  if (UVSIZE >= sizeof(value) || value <= UV_MAX)
+    sv = newSVuv((UV)(value));
+  else {
+    //sv = newSVpvf("%llu", value); doesn't work in non 64bit Perl
+    char temp[256];
+    sprintf(temp, "%llu", value);
+    sv = newSVpv(temp, 0);
+  }
+  return sv_2mortal(sv);
+}
+%#endif
+}
+
+%fragment(SWIG_AsVal_frag(unsigned long long),"header",
+	  fragment="SWIG_LongLongAvailable",
+	  fragment="<stdlib.h>",
+	  fragment="SWIG_CanCastAsInteger") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERN int
+SWIG_AsVal_dec(unsigned long long)(SV *obj, unsigned long long *val)
+{
+  if (SvUOK(obj)) {
+    /* pretty sure this should be conditional on
+     * (UVSIZE <= sizeof(*val) || v <= ULLONG_MAX) */
+    if (val) *val = SvUV(obj);
+    return SWIG_OK;
+  } else  if (SvIOK(obj)) {
+    IV v = SvIV(obj);
+    if (v >= 0 && (IVSIZE <= sizeof(*val) || v <= ULLONG_MAX)) {
+      if (val) *val = v;
+      return SWIG_OK;
+    } else {
+      return SWIG_OverflowError;
+    }
+  } else {
+    int dispatch = 0;
+    const char *nptr = SvPV_nolen(obj);
+    if (nptr) {
+      char *endptr;
+      unsigned long long v;
+      errno = 0;
+      v = strtoull(nptr, &endptr,0);
+      if (errno == ERANGE) {
+	errno = 0;
+	return SWIG_OverflowError;
+      } else {
+	if (*endptr == '\0') {
+	  if (val) *val = v;
+	  return SWIG_Str2NumCast(SWIG_OK);
+	}
+      }
+    }
+    if (!dispatch) {
+      const double mant_max = 1LL << DBL_MANT_DIG;
+      double d;
+      int res = SWIG_AddCast(SWIG_AsVal(double)(obj,&d));
+      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
+	if (val) *val = (unsigned long long)(d);
+	return res;
+      }
+    }
+  }
+  return SWIG_TypeError;
+}
+%#endif
+}
+
+/* double */
+
+%fragment(SWIG_From_frag(double),"header") {
+SWIGINTERNINLINE SV *
+SWIG_From_dec(double)(double value)
+{
+  return sv_2mortal(newSVnv(value));
+}
+}
+
+%fragment(SWIG_AsVal_frag(double),"header") {
+SWIGINTERN int
+SWIG_AsVal_dec(double)(SV *obj, double *val)
+{
+  if (SvNIOK(obj)) {
+    if (val) *val = SvNV(obj);
+    return SWIG_OK;
+  } else if (SvIOK(obj)) {
+    if (val) *val = (double) SvIV(obj);
+    return SWIG_AddCast(SWIG_OK);
+  } else {
+    const char *nptr = SvPV_nolen(obj);
+    if (nptr) {
+      char *endptr;
+      double v;
+      errno = 0;
+      v = strtod(nptr, &endptr);
+      if (errno == ERANGE) {
+	errno = 0;
+	return SWIG_OverflowError;
+      } else {
+	if (*endptr == '\0') {
+	  if (val) *val = v;
+	  return SWIG_Str2NumCast(SWIG_OK);
+	}
+      }
+    }
+  }
+  return SWIG_TypeError;
+}
+}
diff --git a/share/swig/3.0.12/perl5/perlrun.swg b/share/swig/3.0.12/perl5/perlrun.swg
new file mode 100644
index 0000000..d1865de
--- /dev/null
+++ b/share/swig/3.0.12/perl5/perlrun.swg
@@ -0,0 +1,511 @@
+/* -----------------------------------------------------------------------------
+ * perlrun.swg
+ *
+ * This file contains the runtime support for Perl modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef PERL_OBJECT
+#define SWIG_PERL_OBJECT_DECL CPerlObj *SWIGUNUSEDPARM(pPerl),
+#define SWIG_PERL_OBJECT_CALL pPerl,
+#else
+#define SWIG_PERL_OBJECT_DECL
+#define SWIG_PERL_OBJECT_CALL
+#endif
+
+/* Common SWIG API */
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pp, type, flags)           SWIG_Perl_ConvertPtr(SWIG_PERL_OBJECT_CALL obj, pp, type, flags)
+#define SWIG_ConvertPtrAndOwn(obj, pp, type, flags,own) SWIG_Perl_ConvertPtrAndOwn(SWIG_PERL_OBJECT_CALL obj, pp, type, flags, own)
+#define SWIG_NewPointerObj(p, type, flags)              SWIG_Perl_NewPointerObj(SWIG_PERL_OBJECT_CALL p, type, flags)
+#define swig_owntype                                    int
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, p, s, type)             SWIG_Perl_ConvertPacked(SWIG_PERL_OBJECT_CALL obj, p, s, type)
+#define SWIG_NewPackedObj(p, s, type)	                SWIG_Perl_NewPackedObj(SWIG_PERL_OBJECT_CALL p, s, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Perl_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer)             SWIG_Perl_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Perl_ErrorType(code)               
+#define SWIG_Error(code, msg)            		sv_setpvf(get_sv("@", GV_ADD), "%s %s", SWIG_ErrorType(code), msg)
+#define SWIG_fail                        		goto fail						    
+
+/* Perl-specific SWIG API */
+
+#define SWIG_MakePtr(sv, ptr, type, flags)              SWIG_Perl_MakePtr(SWIG_PERL_OBJECT_CALL sv, ptr, type, flags)
+#define SWIG_MakePackedObj(sv, p, s, type)	        SWIG_Perl_MakePackedObj(SWIG_PERL_OBJECT_CALL sv, p, s, type)
+#define SWIG_SetError(str)                              SWIG_Error(SWIG_RuntimeError, str)
+
+
+#define SWIG_PERL_DECL_ARGS_1(arg1)                     (SWIG_PERL_OBJECT_DECL arg1)
+#define SWIG_PERL_CALL_ARGS_1(arg1)                     (SWIG_PERL_OBJECT_CALL arg1)
+#define SWIG_PERL_DECL_ARGS_2(arg1, arg2)               (SWIG_PERL_OBJECT_DECL arg1, arg2)
+#define SWIG_PERL_CALL_ARGS_2(arg1, arg2)               (SWIG_PERL_OBJECT_CALL arg1, arg2)
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SWIG_OWNER   SWIG_POINTER_OWN
+#define SWIG_SHADOW  SWIG_OWNER << 1
+
+#define SWIG_MAYBE_PERL_OBJECT SWIG_PERL_OBJECT_DECL
+
+/* SWIG Perl macros */
+
+/* Macro to declare an XS function */
+#ifndef XSPROTO
+#   define XSPROTO(name) void name(pTHX_ CV* cv)
+#endif
+
+/* Macro to call an XS function */
+#ifdef PERL_OBJECT 
+#  define SWIG_CALLXS(_name) _name(cv,pPerl) 
+#else 
+#  ifndef MULTIPLICITY 
+#    define SWIG_CALLXS(_name) _name(cv) 
+#  else 
+#    define SWIG_CALLXS(_name) _name(PERL_GET_THX, cv) 
+#  endif 
+#endif 
+
+#ifdef PERL_OBJECT
+#define MAGIC_PPERL  CPerlObj *pPerl = (CPerlObj *) this;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef int (CPerlObj::*SwigMagicFunc)(SV *, MAGIC *);
+#ifdef __cplusplus
+}
+#endif
+
+#define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
+#define SWIGCLASS_STATIC
+
+#else /* PERL_OBJECT */
+
+#define MAGIC_PPERL
+#define SWIGCLASS_STATIC static SWIGUNUSED
+
+#ifndef MULTIPLICITY
+#define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef int (*SwigMagicFunc)(SV *, MAGIC *);
+#ifdef __cplusplus
+}
+#endif
+
+#else /* MULTIPLICITY */
+
+#define SWIG_MAGIC(a,b) (struct interpreter *interp, SV *a, MAGIC *b)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MULTIPLICITY */
+#endif /* PERL_OBJECT */
+
+#  ifdef PERL_OBJECT
+#    define SWIG_croak_null() SWIG_Perl_croak_null(pPerl)
+static void SWIGUNUSED SWIG_Perl_croak_null(CPerlObj *pPerl)
+#  else
+static void SWIGUNUSED SWIG_croak_null()
+#  endif
+{
+  SV *err = get_sv("@", GV_ADD);
+#  if (PERL_VERSION < 6)
+  croak("%_", err);
+#  else
+  if (sv_isobject(err))
+    croak(0);
+  else
+    croak("%s", SvPV_nolen(err));
+#  endif
+}
+
+
+/* 
+   Define how strict is the cast between strings and integers/doubles
+   when overloading between these types occurs.
+   
+   The default is making it as strict as possible by using SWIG_AddCast
+   when needed.
+   
+   You can use -DSWIG_PERL_NO_STRICT_STR2NUM at compilation time to
+   disable the SWIG_AddCast, making the casting between string and
+   numbers less strict.
+
+   In the end, we try to solve the overloading between strings and
+   numerical types in the more natural way, but if you can avoid it,
+   well, avoid it using %rename, for example.
+*/
+#ifndef SWIG_PERL_NO_STRICT_STR2NUM
+# ifndef SWIG_PERL_STRICT_STR2NUM
+#  define SWIG_PERL_STRICT_STR2NUM
+# endif
+#endif
+#ifdef SWIG_PERL_STRICT_STR2NUM
+/* string takes precedence */
+#define SWIG_Str2NumCast(x) SWIG_AddCast(x)  
+#else
+/* number takes precedence */
+#define SWIG_Str2NumCast(x) x
+#endif
+
+
+
+#include <stdlib.h>
+
+SWIGRUNTIME const char *
+SWIG_Perl_TypeProxyName(const swig_type_info *type) {
+  if (!type) return NULL;
+  if (type->clientdata != NULL) {
+    return (const char*) type->clientdata;
+  } 
+  else {
+    return type->name;
+  }
+}
+
+/* Identical to SWIG_TypeCheck, except for strcmp comparison */
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeProxyCheck(const char *c, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(SWIG_Perl_TypeProxyName(iter->type), c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/* Function for getting a pointer value */
+
+SWIGRUNTIME int
+SWIG_Perl_ConvertPtrAndOwn(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags, int *own) {
+  swig_cast_info *tc;
+  void *voidptr = (void *)0;
+  SV *tsv = 0;
+
+  if (own)
+    *own = 0;
+
+  /* If magical, apply more magic */
+  if (SvGMAGICAL(sv))
+    mg_get(sv);
+
+  /* Check to see if this is an object */
+  if (sv_isobject(sv)) {
+    IV tmp = 0;
+    tsv = (SV*) SvRV(sv);
+    if ((SvTYPE(tsv) == SVt_PVHV)) {
+      MAGIC *mg;
+      if (SvMAGICAL(tsv)) {
+        mg = mg_find(tsv,'P');
+        if (mg) {
+          sv = mg->mg_obj;
+          if (sv_isobject(sv)) {
+	    tsv = (SV*)SvRV(sv);
+            tmp = SvIV(tsv);
+          }
+        }
+      } else {
+        return SWIG_ERROR;
+      }
+    } else {
+      tmp = SvIV(tsv);
+    }
+    voidptr = INT2PTR(void *,tmp);
+  } else if (! SvOK(sv)) {            /* Check for undef */
+    *(ptr) = (void *) 0;
+    return SWIG_OK;
+  } else if (SvTYPE(sv) == SVt_RV) {  /* Check for NULL pointer */
+    if (!SvROK(sv)) {
+      /* In Perl 5.12 and later, SVt_RV == SVt_IV, so sv could be a valid integer value.  */
+      if (SvIOK(sv)) {
+        return SWIG_ERROR;
+      } else {
+        /* NULL pointer (reference to undef). */
+        *(ptr) = (void *) 0;
+        return SWIG_OK;
+      }
+    } else {
+      return SWIG_ERROR;
+    }
+  } else {                            /* Don't know what it is */
+    return SWIG_ERROR;
+  }
+  if (_t) {
+    /* Now see if the types match */
+    char *_c = HvNAME(SvSTASH(SvRV(sv)));
+    tc = SWIG_TypeProxyCheck(_c,_t);
+#ifdef SWIG_DIRECTORS
+    if (!tc && !sv_derived_from(sv,SWIG_Perl_TypeProxyName(_t))) {
+#else
+    if (!tc) {
+#endif
+      return SWIG_ERROR;
+    }
+    {
+      int newmemory = 0;
+      *ptr = SWIG_TypeCast(tc,voidptr,&newmemory);
+      if (newmemory == SWIG_CAST_NEW_MEMORY) {
+        assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+        if (own)
+          *own = *own | SWIG_CAST_NEW_MEMORY;
+      }
+    }
+  } else {
+    *ptr = voidptr;
+  }
+
+  /* 
+   *  DISOWN implementation: we need a perl guru to check this one.
+   */
+  if (tsv && (flags & SWIG_POINTER_DISOWN)) {
+    /* 
+     *  almost copy paste code from below SWIG_POINTER_OWN setting
+     */
+    SV *obj = sv;
+    HV *stash = SvSTASH(SvRV(obj));
+    GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
+    if (isGV(gv)) {
+      HV *hv = GvHVn(gv);
+      /*
+       * To set ownership (see below), a newSViv(1) entry is added. 
+       * Hence, to remove ownership, we delete the entry.
+       */
+      if (hv_exists_ent(hv, obj, 0)) {
+	hv_delete_ent(hv, obj, 0, 0);
+      }
+    }
+  }
+  return SWIG_OK;
+}
+
+SWIGRUNTIME int
+SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
+  return SWIG_Perl_ConvertPtrAndOwn(sv, ptr, _t, flags, 0);
+}
+
+SWIGRUNTIME void
+SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
+  if (ptr && (flags & (SWIG_SHADOW | SWIG_POINTER_OWN))) {
+    SV *self;
+    SV *obj=newSV(0);
+    HV *hash=newHV();
+    HV *stash;
+    sv_setref_pv(obj, SWIG_Perl_TypeProxyName(t), ptr);
+    stash=SvSTASH(SvRV(obj));
+    if (flags & SWIG_POINTER_OWN) {
+      HV *hv;
+      GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
+      if (!isGV(gv))
+        gv_init(gv, stash, "OWNER", 5, FALSE);
+      hv=GvHVn(gv);
+      hv_store_ent(hv, obj, newSViv(1), 0);
+    }
+    sv_magic((SV *)hash, (SV *)obj, 'P', Nullch, 0);
+    SvREFCNT_dec(obj);
+    self=newRV_noinc((SV *)hash);
+    sv_setsv(sv, self);
+    SvREFCNT_dec((SV *)self);
+    sv_bless(sv, stash);
+  }
+  else {
+    sv_setref_pv(sv, SWIG_Perl_TypeProxyName(t), ptr);
+  }
+}
+
+SWIGRUNTIMEINLINE SV *
+SWIG_Perl_NewPointerObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
+  SV *result = sv_newmortal();
+  SWIG_MakePtr(result, ptr, t, flags);
+  return result;
+}
+
+SWIGRUNTIME void
+SWIG_Perl_MakePackedObj(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(SWIG_Perl_TypeProxyName(type))) > 1000) return;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  strcpy(r,SWIG_Perl_TypeProxyName(type));
+  sv_setpv(sv, result);
+}
+
+SWIGRUNTIME SV *
+SWIG_Perl_NewPackedObj(SWIG_MAYBE_PERL_OBJECT void *ptr, int sz, swig_type_info *type) {
+  SV *result = sv_newmortal();
+  SWIG_Perl_MakePackedObj(result, ptr, sz, type);
+  return result;
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Perl_ConvertPacked(SWIG_MAYBE_PERL_OBJECT SV *obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c = 0;
+
+  if ((!obj) || (!SvOK(obj))) return SWIG_ERROR;
+  c = SvPV_nolen(obj);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') return SWIG_ERROR;
+  c++;
+  c = SWIG_UnpackData(c,ptr,sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c,ty);
+    if (!tc) return SWIG_ERROR;
+  }
+  return SWIG_OK;
+}
+
+
+/* Macros for low-level exception handling */
+#define SWIG_croak(x)    { SWIG_Error(SWIG_RuntimeError, x); SWIG_fail; }
+
+
+typedef XSPROTO(SwigPerlWrapper);
+typedef SwigPerlWrapper *SwigPerlWrapperPtr;
+
+/* Structure for command table */
+typedef struct {
+  const char         *name;
+  SwigPerlWrapperPtr  wrapper;
+} swig_command_info;
+
+/* Information for constant table */
+
+#define SWIG_INT     1
+#define SWIG_FLOAT   2
+#define SWIG_STRING  3
+#define SWIG_POINTER 4
+#define SWIG_BINARY  5
+
+/* Constant information structure */
+typedef struct swig_constant_info {
+    int              type;
+    const char      *name;
+    long             lvalue;
+    double           dvalue;
+    void            *pvalue;
+    swig_type_info **ptype;
+} swig_constant_info;
+
+
+/* Structure for variable table */
+typedef struct {
+  const char   *name;
+  SwigMagicFunc   set;
+  SwigMagicFunc   get;
+  swig_type_info  **type;
+} swig_variable_info;
+
+/* Magic variable code */
+#ifndef PERL_OBJECT
+# ifdef __cplusplus
+#  define swig_create_magic(s,a,b,c) _swig_create_magic(s,const_cast<char*>(a),b,c)
+# else
+#  define swig_create_magic(s,a,b,c) _swig_create_magic(s,(char*)(a),b,c)
+# endif
+# ifndef MULTIPLICITY
+SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *)) 
+# else
+SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *)) 
+# endif
+#else
+#  define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
+SWIGRUNTIME void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *)) 
+#endif
+{
+  MAGIC *mg;
+  sv_magic(sv,sv,'U',name,strlen(name));
+  mg = mg_find(sv,'U');
+  mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
+  mg->mg_virtual->svt_get = (SwigMagicFunc) get;
+  mg->mg_virtual->svt_set = (SwigMagicFunc) set;
+  mg->mg_virtual->svt_len = 0;
+  mg->mg_virtual->svt_clear = 0;
+  mg->mg_virtual->svt_free = 0;
+}
+
+
+SWIGRUNTIME swig_module_info *
+SWIG_Perl_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
+  static void *type_pointer = (void *)0;
+  SV *pointer;
+
+  /* first check if pointer already created */
+  if (!type_pointer) {
+    pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE | GV_ADDMULTI);
+    if (pointer && SvOK(pointer)) {
+      type_pointer = INT2PTR(swig_type_info **, SvIV(pointer));
+    }
+  }
+
+  return (swig_module_info *) type_pointer;
+}
+
+SWIGRUNTIME void
+SWIG_Perl_SetModule(swig_module_info *module) {
+  SV *pointer;
+
+  /* create a new pointer */
+  pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TRUE | GV_ADDMULTI);
+  sv_setiv(pointer, PTR2IV(module));
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/share/swig/2.0.11/perl5/perlruntime.swg b/share/swig/3.0.12/perl5/perlruntime.swg
index f948023..f948023 100644
--- a/share/swig/2.0.11/perl5/perlruntime.swg
+++ b/share/swig/3.0.12/perl5/perlruntime.swg
diff --git a/share/swig/2.0.11/perl5/perlstrings.swg b/share/swig/3.0.12/perl5/perlstrings.swg
index 242a9c9..242a9c9 100644
--- a/share/swig/2.0.11/perl5/perlstrings.swg
+++ b/share/swig/3.0.12/perl5/perlstrings.swg
diff --git a/share/swig/3.0.12/perl5/perltypemaps.swg b/share/swig/3.0.12/perl5/perltypemaps.swg
new file mode 100644
index 0000000..ffec5ea
--- /dev/null
+++ b/share/swig/3.0.12/perl5/perltypemaps.swg
@@ -0,0 +1,98 @@
+/* ------------------------------------------------------------
+ *  Typemap specializations for Perl
+ * ------------------------------------------------------------ */
+
+/* ------------------------------------------------------------
+ *  Fragment section
+ * ------------------------------------------------------------ */
+
+/*
+  in Perl we need to pass the CPerlObj value, sometimes, so, we define
+  the decl/call macros as needed.
+*/
+
+#define SWIG_AS_DECL_ARGS SWIG_PERL_DECL_ARGS_2
+#define SWIG_AS_CALL_ARGS SWIG_PERL_CALL_ARGS_2
+
+#define SWIG_FROM_DECL_ARGS  SWIG_PERL_DECL_ARGS_1
+#define SWIG_FROM_CALL_ARGS  SWIG_PERL_CALL_ARGS_1
+
+
+/* Include fundamental fragment definitions */
+%include <typemaps/fragments.swg>
+
+/* Look for user fragments file. */
+%include <perlfragments.swg>
+
+/* Perl fragments for primitive types */
+%include <perlprimtypes.swg>
+
+/* Perl fragments for char* strings */
+%include <perlstrings.swg>
+
+
+/* ------------------------------------------------------------
+ *  Unified typemap section
+ * ------------------------------------------------------------ */
+
+/* director support in Perl is experimental */
+#ifndef SWIG_DIRECTOR_TYPEMAPS
+#define SWIG_DIRECTOR_TYPEMAPS
+#endif
+
+
+/* Perl types */
+#define SWIG_Object                      SV *
+#define VOID_Object                      sv_newmortal()
+
+/* Perl $shadow flag */
+#define %newpointer_flags                $shadow
+#define %newinstance_flags               $shadow
+
+
+/* Complete overload of the output/constant/exception macros */
+
+/* output */
+%define %set_output(obj) $result = obj; argvi++ %enddef
+
+/* append output */
+%define %append_output(obj) if (argvi >= items) EXTEND(sp,1); %set_output(obj) %enddef
+
+/* variable output */
+%define %set_varoutput(obj) sv_setsv($result,obj)  %enddef
+
+/* constant */
+%define %set_constant(name, obj) %begin_block
+  SV *sv = get_sv((char*) SWIG_prefix name, TRUE | 0x2 | GV_ADDMULTI);
+  sv_setsv(sv, obj);
+  SvREADONLY_on(sv);
+%end_block %enddef
+
+/* raise exception */
+%define %raise(obj, type, desc) sv_setsv(get_sv("@", GV_ADD), obj); SWIG_fail %enddef
+
+/* Include the unified typemap library */
+%include <typemaps/swigtypemaps.swg>
+
+/*  ------------------------------------------------------------
+ *  Perl extra typemaps / typemap overrides
+ * ------------------------------------------------------------ */
+
+%typemap(varout,type="$1_descriptor") SWIGTYPE *, SWIGTYPE []  
+    "sv_setiv(SvRV($result),PTR2IV($1));"; 
+
+%typemap(varout,type="$1_descriptor") SWIGTYPE &
+    "sv_setiv(SvRV($result),PTR2IV(&$1));"; 
+
+%typemap(varout,type="$1_descriptor") SWIGTYPE &&
+    "sv_setiv(SvRV($result),PTR2IV(&$1));"; 
+
+%typemap(varout,type="$&1_descriptor") SWIGTYPE
+    "sv_setiv(SvRV($result), PTR2IV(&$1));";
+
+%typemap(varout,type="$1_descriptor") SWIGTYPE (CLASS::*) {
+  SWIG_MakePackedObj($result, (void *) &$1, sizeof($1_type), $1_descriptor);
+}
+
+%typemap(varout) SWIGTYPE *const = SWIGTYPE *;
+
diff --git a/share/swig/2.0.11/perl5/perluserdir.swg b/share/swig/3.0.12/perl5/perluserdir.swg
index 718440e..718440e 100644
--- a/share/swig/2.0.11/perl5/perluserdir.swg
+++ b/share/swig/3.0.12/perl5/perluserdir.swg
diff --git a/share/swig/2.0.11/perl5/reference.i b/share/swig/3.0.12/perl5/reference.i
index b424c53..b424c53 100644
--- a/share/swig/2.0.11/perl5/reference.i
+++ b/share/swig/3.0.12/perl5/reference.i
diff --git a/share/swig/3.0.12/perl5/std_common.i b/share/swig/3.0.12/perl5/std_common.i
new file mode 100644
index 0000000..7c1ff23
--- /dev/null
+++ b/share/swig/3.0.12/perl5/std_common.i
@@ -0,0 +1,28 @@
+/* -----------------------------------------------------------------------------
+ * std_common.i
+ *
+ * SWIG typemaps for STL - common utilities
+ * ----------------------------------------------------------------------------- */
+
+%include <std/std_except.i>
+
+%apply size_t { std::size_t };
+
+%fragment("<string>");
+%{
+SWIGINTERN
+double SwigSvToNumber(SV* sv) {
+    return SvIOK(sv) ? double(SvIVX(sv)) : SvNVX(sv);
+}
+SWIGINTERN
+std::string SwigSvToString(SV* sv) {
+    STRLEN len;
+    char *ptr = SvPV(sv, len);
+    return std::string(ptr, len);
+}
+SWIGINTERN
+void SwigSvFromString(SV* sv, const std::string& s) {
+    sv_setpvn(sv,s.data(),s.size());
+}
+%}
+
diff --git a/share/swig/2.0.11/tcl/std_deque.i b/share/swig/3.0.12/perl5/std_deque.i
index cb98f6c..cb98f6c 100644
--- a/share/swig/2.0.11/tcl/std_deque.i
+++ b/share/swig/3.0.12/perl5/std_deque.i
diff --git a/share/swig/2.0.11/r/std_except.i b/share/swig/3.0.12/perl5/std_except.i
index af98428..af98428 100644
--- a/share/swig/2.0.11/r/std_except.i
+++ b/share/swig/3.0.12/perl5/std_except.i
diff --git a/share/swig/3.0.12/perl5/std_list.i b/share/swig/3.0.12/perl5/std_list.i
new file mode 100644
index 0000000..cd5a611
--- /dev/null
+++ b/share/swig/3.0.12/perl5/std_list.i
@@ -0,0 +1,373 @@
+/* -----------------------------------------------------------------------------
+ * std_list.i
+ *
+ * SWIG typemaps for std::list types
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+%include <exception.i>
+
+// containers
+
+
+// ------------------------------------------------------------------------
+// std::list
+// 
+// The aim of all that follows would be to integrate std::list with 
+// Perl as much as possible, namely, to allow the user to pass and 
+// be returned Perl arrays.
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+// 
+//   -- f(std::list<T>), f(const std::list<T>&), f(const std::list<T>*):
+//      the parameter being read-only, either a Perl sequence or a
+//      previously wrapped std::list<T> can be passed.
+//   -- f(std::list<T>&), f(std::list<T>*):
+//      the parameter must be modified; therefore, only a wrapped std::list
+//      can be passed.
+//   -- std::list<T> f():
+//      the list is returned by copy; therefore, a Perl sequence of T:s 
+//      is returned which is most easily used in other Perl functions
+//   -- std::list<T>& f(), std::list<T>* f(), const std::list<T>& f(),
+//      const std::list<T>* f():
+//      the list is returned by reference; therefore, a wrapped std::list
+//      is returned
+// ------------------------------------------------------------------------
+
+%{
+#include <list>
+%}
+%fragment("<algorithm>");
+%fragment("<stdexcept>");
+
+// exported class
+
+namespace std {
+    
+    template<class T> class list {
+        %typemap(in) list<T> (std::list<T>* v) {
+            if (SWIG_ConvertPtr($input,(void **) &v, 
+                                $&1_descriptor,1) != -1) {
+                $1 = *v;
+            } else if (SvROK($input)) {
+                AV *av = (AV *)SvRV($input);
+                if (SvTYPE(av) != SVt_PVAV)
+                    SWIG_croak("Type error in argument $argnum of $symname. "
+                               "Expected an array of " #T);
+                SV **tv;
+                I32 len = av_len(av) + 1;
+                T* obj;
+                for (int i=0; i<len; i++) {
+                    tv = av_fetch(av, i, 0);
+                    if (SWIG_ConvertPtr(*tv, (void **)&obj, 
+                                        $descriptor(T *),0) != -1) {
+                        $1.push_back(*obj);
+                    } else {
+                        SWIG_croak("Type error in argument $argnum of "
+                                   "$symname. "
+                                   "Expected an array of " #T);
+                    }
+                }
+            } else {
+                SWIG_croak("Type error in argument $argnum of $symname. "
+                           "Expected an array of " #T);
+            }
+        }
+        %typemap(in) const list<T>& (std::list<T> temp,
+                                       std::list<T>* v),
+                     const list<T>* (std::list<T> temp,
+                                       std::list<T>* v) {
+            if (SWIG_ConvertPtr($input,(void **) &v, 
+                                $1_descriptor,1) != -1) {
+                $1 = v;
+            } else if (SvROK($input)) {
+                AV *av = (AV *)SvRV($input);
+                if (SvTYPE(av) != SVt_PVAV)
+                    SWIG_croak("Type error in argument $argnum of $symname. "
+                               "Expected an array of " #T);
+                SV **tv;
+                I32 len = av_len(av) + 1;
+                T* obj;
+                for (int i=0; i<len; i++) {
+                    tv = av_fetch(av, i, 0);
+                    if (SWIG_ConvertPtr(*tv, (void **)&obj, 
+                                        $descriptor(T *),0) != -1) {
+                        temp.push_back(*obj);
+                    } else {
+                        SWIG_croak("Type error in argument $argnum of "
+                                   "$symname. "
+                                   "Expected an array of " #T);
+                    }
+                }
+                $1 = &temp;
+            } else {
+                SWIG_croak("Type error in argument $argnum of $symname. "
+                           "Expected an array of " #T);
+            }
+        }
+        %typemap(out) list<T> {
+	    std::list< T >::const_iterator i;
+            unsigned int j;
+            int len = $1.size();
+            SV **svs = new SV*[len];
+            for (i=$1.begin(), j=0; i!=$1.end(); i++, j++) {
+                T* ptr = new T(*i);
+                svs[j] = sv_newmortal();
+                SWIG_MakePtr(svs[j], (void*) ptr, 
+                             $descriptor(T *), $shadow|$owner);
+            }
+            AV *myav = av_make(len, svs);
+            delete[] svs;
+            $result = newRV_noinc((SV*) myav);
+            sv_2mortal($result);
+            argvi++;
+        }
+        %typecheck(SWIG_TYPECHECK_LIST) list<T> {
+            {
+                /* wrapped list? */
+                std::list< T >* v;
+                if (SWIG_ConvertPtr($input,(void **) &v, 
+                                    $1_&descriptor,0) != -1) {
+                    $1 = 1;
+                } else if (SvROK($input)) {
+                    /* native sequence? */
+                    AV *av = (AV *)SvRV($input);
+                    if (SvTYPE(av) == SVt_PVAV) {
+                        SV **tv;
+                        I32 len = av_len(av) + 1;
+                        if (len == 0) {
+                            /* an empty sequence can be of any type */
+                            $1 = 1;
+                        } else {
+                            /* check the first element only */
+                            T* obj;
+                            tv = av_fetch(av, 0, 0);
+                            if (SWIG_ConvertPtr(*tv, (void **)&obj, 
+                                                $descriptor(T *),0) != -1)
+                                $1 = 1;
+                            else
+                                $1 = 0;
+                        }
+                    }
+                } else {
+                    $1 = 0;
+                }
+            }
+        }
+        %typecheck(SWIG_TYPECHECK_LIST) const list<T>&,
+                                          const list<T>* {
+            {
+                /* wrapped list? */
+                std::list< T >* v;
+                if (SWIG_ConvertPtr($input,(void **) &v, 
+                                    $1_descriptor,0) != -1) {
+                    $1 = 1;
+                } else if (SvROK($input)) {
+                    /* native sequence? */
+                    AV *av = (AV *)SvRV($input);
+                    if (SvTYPE(av) == SVt_PVAV) {
+                        SV **tv;
+                        I32 len = av_len(av) + 1;
+                        if (len == 0) {
+                            /* an empty sequence can be of any type */
+                            $1 = 1;
+                        } else {
+                            /* check the first element only */
+                            T* obj;
+                            tv = av_fetch(av, 0, 0);
+                            if (SWIG_ConvertPtr(*tv, (void **)&obj, 
+                                                $descriptor(T *),0) != -1)
+                                $1 = 1;
+                            else
+                                $1 = 0;
+                        }
+                    }
+                } else {
+                    $1 = 0;
+                }
+            }
+        }
+      public:
+        typedef size_t size_type;
+        typedef T value_type;
+        typedef const value_type& const_reference;
+
+        list();
+        list(const list<T> &);
+
+        unsigned int size() const;
+        bool empty() const;
+        void clear();
+        %rename(push) push_back;
+        void push_back(const T& x);
+    };
+
+
+    // specializations for built-ins
+
+    %define specialize_std_list(T,CHECK_T,TO_T,FROM_T)
+    template<> class list<T> {
+        %typemap(in) list<T> (std::list<T>* v) {
+            if (SWIG_ConvertPtr($input,(void **) &v, 
+                                $&1_descriptor,1) != -1){
+                $1 = *v;
+            } else if (SvROK($input)) {
+                AV *av = (AV *)SvRV($input);
+                if (SvTYPE(av) != SVt_PVAV)
+                    SWIG_croak("Type error in argument $argnum of $symname. "
+                               "Expected an array of " #T);
+                SV **tv;
+                I32 len = av_len(av) + 1;
+                for (int i=0; i<len; i++) {
+                    tv = av_fetch(av, i, 0);
+                    if (CHECK_T(*tv)) {
+                        $1.push_back(TO_T(*tv));
+                    } else {
+                        SWIG_croak("Type error in argument $argnum of "
+                                   "$symname. "
+                                   "Expected an array of " #T);
+                    }
+                }
+            } else {
+                SWIG_croak("Type error in argument $argnum of $symname. "
+                           "Expected an array of " #T);
+            }
+        }
+        %typemap(in) const list<T>& (std::list<T> temp,
+                                       std::list<T>* v),
+                     const list<T>* (std::list<T> temp,
+                                       std::list<T>* v) {
+            if (SWIG_ConvertPtr($input,(void **) &v, 
+                                $1_descriptor,1) != -1) {
+                $1 = v;
+            } else if (SvROK($input)) {
+                AV *av = (AV *)SvRV($input);
+                if (SvTYPE(av) != SVt_PVAV)
+                    SWIG_croak("Type error in argument $argnum of $symname. "
+                               "Expected an array of " #T);
+                SV **tv;
+                I32 len = av_len(av) + 1;
+                T* obj;
+                for (int i=0; i<len; i++) {
+                    tv = av_fetch(av, i, 0);
+                    if (CHECK_T(*tv)) {
+                        temp.push_back(TO_T(*tv));
+                    } else {
+                        SWIG_croak("Type error in argument $argnum of "
+                                   "$symname. "
+                                   "Expected an array of " #T);
+                    }
+                }
+                $1 = &temp;
+            } else {
+                SWIG_croak("Type error in argument $argnum of $symname. "
+                           "Expected an array of " #T);
+            }
+        }
+        %typemap(out) list<T> {
+	    std::list< T >::const_iterator i;
+            unsigned int j;
+            int len = $1.size();
+            SV **svs = new SV*[len];
+            for (i=$1.begin(), j=0; i!=$1.end(); i++, j++) {
+                svs[j] = sv_newmortal();
+                FROM_T(svs[j], *i);
+            }
+            AV *myav = av_make(len, svs);
+            delete[] svs;
+            $result = newRV_noinc((SV*) myav);
+            sv_2mortal($result);
+            argvi++;
+        }
+        %typecheck(SWIG_TYPECHECK_LIST) list<T> {
+            {
+                /* wrapped list? */
+                std::list< T >* v;
+                if (SWIG_ConvertPtr($input,(void **) &v, 
+                                    $1_&descriptor,0) != -1) {
+                    $1 = 1;
+                } else if (SvROK($input)) {
+                    /* native sequence? */
+                    AV *av = (AV *)SvRV($input);
+                    if (SvTYPE(av) == SVt_PVAV) {
+                        SV **tv;
+                        I32 len = av_len(av) + 1;
+                        if (len == 0) {
+                            /* an empty sequence can be of any type */
+                            $1 = 1;
+                        } else {
+                            /* check the first element only */
+                            tv = av_fetch(av, 0, 0);
+                            if (CHECK_T(*tv))
+                                $1 = 1;
+                            else
+                                $1 = 0;
+                        }
+                    }
+                } else {
+                    $1 = 0;
+                }
+            }
+        }
+        %typecheck(SWIG_TYPECHECK_LIST) const list<T>&,
+                                          const list<T>* {
+            {
+                /* wrapped list? */
+                std::list< T >* v;
+                if (SWIG_ConvertPtr($input,(void **) &v, 
+                                    $1_descriptor,0) != -1) {
+                    $1 = 1;
+                } else if (SvROK($input)) {
+                    /* native sequence? */
+                    AV *av = (AV *)SvRV($input);
+                    if (SvTYPE(av) == SVt_PVAV) {
+                        SV **tv;
+                        I32 len = av_len(av) + 1;
+                        if (len == 0) {
+                            /* an empty sequence can be of any type */
+                            $1 = 1;
+                        } else {
+                            /* check the first element only */
+                            tv = av_fetch(av, 0, 0);
+                            if (CHECK_T(*tv))
+                                $1 = 1;
+                            else
+                                $1 = 0;
+                        }
+                    }
+                } else {
+                    $1 = 0;
+                }
+            }
+        }
+      public:
+        typedef size_t size_type;
+        typedef T value_type;
+        typedef const value_type& const_reference;
+
+        list();
+        list(const list<T> &);
+
+        unsigned int size() const;
+        bool empty() const;
+        void clear();
+        %rename(push) push_back;
+        void push_back(T x);
+    };
+    %enddef
+
+    specialize_std_list(bool,SvIOK,SvIVX,sv_setiv);
+    specialize_std_list(char,SvIOK,SvIVX,sv_setiv);
+    specialize_std_list(int,SvIOK,SvIVX,sv_setiv);
+    specialize_std_list(short,SvIOK,SvIVX,sv_setiv);
+    specialize_std_list(long,SvIOK,SvIVX,sv_setiv);
+    specialize_std_list(unsigned char,SvIOK,SvIVX,sv_setiv);
+    specialize_std_list(unsigned int,SvIOK,SvIVX,sv_setiv);
+    specialize_std_list(unsigned short,SvIOK,SvIVX,sv_setiv);
+    specialize_std_list(unsigned long,SvIOK,SvIVX,sv_setiv);
+    specialize_std_list(float,SvNIOK,SwigSvToNumber,sv_setnv);
+    specialize_std_list(double,SvNIOK,SwigSvToNumber,sv_setnv);
+    specialize_std_list(std::string,SvPOK,SvPVX,SwigSvFromString);
+
+}
+
diff --git a/share/swig/3.0.12/perl5/std_map.i b/share/swig/3.0.12/perl5/std_map.i
new file mode 100644
index 0000000..af49ed3
--- /dev/null
+++ b/share/swig/3.0.12/perl5/std_map.i
@@ -0,0 +1,74 @@
+/* -----------------------------------------------------------------------------
+ * std_map.i
+ *
+ * SWIG typemaps for std::map
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+
+// ------------------------------------------------------------------------
+// std::map
+// ------------------------------------------------------------------------
+
+%{
+#include <map>
+%}
+%fragment("<algorithm>");
+%fragment("<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();
+            }
+        }
+    };
+
+// 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/perl5/std_pair.i b/share/swig/3.0.12/perl5/std_pair.i
index 0712ad7..0712ad7 100644
--- a/share/swig/2.0.11/perl5/std_pair.i
+++ b/share/swig/3.0.12/perl5/std_pair.i
diff --git a/share/swig/2.0.11/perl5/std_string.i b/share/swig/3.0.12/perl5/std_string.i
index 6f34f18..6f34f18 100644
--- a/share/swig/2.0.11/perl5/std_string.i
+++ b/share/swig/3.0.12/perl5/std_string.i
diff --git a/share/swig/3.0.12/perl5/std_vector.i b/share/swig/3.0.12/perl5/std_vector.i
new file mode 100644
index 0000000..ec84494
--- /dev/null
+++ b/share/swig/3.0.12/perl5/std_vector.i
@@ -0,0 +1,577 @@
+/* -----------------------------------------------------------------------------
+ * std_vector.i
+ *
+ * SWIG typemaps for std::vector types
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+
+// ------------------------------------------------------------------------
+// std::vector
+// 
+// The aim of all that follows would be to integrate std::vector with 
+// Perl as much as possible, namely, to allow the user to pass and 
+// be returned Perl arrays.
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+// 
+//   -- f(std::vector<T>), f(const std::vector<T>&), f(const std::vector<T>*):
+//      the parameter being read-only, either a Perl sequence or a
+//      previously wrapped std::vector<T> can be passed.
+//   -- f(std::vector<T>&), f(std::vector<T>*):
+//      the parameter must be modified; therefore, only a wrapped std::vector
+//      can be passed.
+//   -- std::vector<T> f():
+//      the vector is returned by copy; therefore, a Perl sequence of T:s 
+//      is returned which is most easily used in other Perl functions
+//   -- std::vector<T>& f(), std::vector<T>* f(), const std::vector<T>& f(),
+//      const std::vector<T>* f():
+//      the vector is returned by reference; therefore, a wrapped std::vector
+//      is returned
+// ------------------------------------------------------------------------
+
+%{
+#include <vector>
+%}
+%fragment("<algorithm>");
+%fragment("<stdexcept>");
+
+// exported class
+
+namespace std {
+    
+    template<class T> class vector {
+        %typemap(in) vector<T> (std::vector<T>* v) {
+            if (SWIG_ConvertPtr($input,(void **) &v, 
+                                $&1_descriptor,1) != -1) {
+                $1 = *v;
+            } else if (SvROK($input)) {
+                AV *av = (AV *)SvRV($input);
+                if (SvTYPE(av) != SVt_PVAV)
+                    SWIG_croak("Type error in argument $argnum of $symname. "
+                               "Expected an array of " #T);
+                SV **tv;
+                I32 len = av_len(av) + 1;
+                T* obj;
+                for (int i=0; i<len; i++) {
+                    tv = av_fetch(av, i, 0);
+                    if (SWIG_ConvertPtr(*tv, (void **)&obj, 
+                                        $descriptor(T *),0) != -1) {
+                        $1.push_back(*obj);
+                    } else {
+                        SWIG_croak("Type error in argument $argnum of "
+                                   "$symname. "
+                                   "Expected an array of " #T);
+                    }
+                }
+            } else {
+                SWIG_croak("Type error in argument $argnum of $symname. "
+                           "Expected an array of " #T);
+            }
+        }
+        %typemap(in) const vector<T>& (std::vector<T> temp,
+                                       std::vector<T>* v),
+                     const vector<T>* (std::vector<T> temp,
+                                       std::vector<T>* v) {
+            if (SWIG_ConvertPtr($input,(void **) &v, 
+                                $1_descriptor,1) != -1) {
+                $1 = v;
+            } else if (SvROK($input)) {
+                AV *av = (AV *)SvRV($input);
+                if (SvTYPE(av) != SVt_PVAV)
+                    SWIG_croak("Type error in argument $argnum of $symname. "
+                               "Expected an array of " #T);
+                SV **tv;
+                I32 len = av_len(av) + 1;
+                T* obj;
+                for (int i=0; i<len; i++) {
+                    tv = av_fetch(av, i, 0);
+                    if (SWIG_ConvertPtr(*tv, (void **)&obj, 
+                                        $descriptor(T *),0) != -1) {
+                        temp.push_back(*obj);
+                    } else {
+                        SWIG_croak("Type error in argument $argnum of "
+                                   "$symname. "
+                                   "Expected an array of " #T);
+                    }
+                }
+                $1 = &temp;
+            } else {
+                SWIG_croak("Type error in argument $argnum of $symname. "
+                           "Expected an array of " #T);
+            }
+        }
+        %typemap(out) vector<T> {
+            size_t len = $1.size();
+            SV **svs = new SV*[len];
+            for (size_t i=0; i<len; i++) {
+                T* ptr = new T($1[i]);
+                svs[i] = sv_newmortal();
+                SWIG_MakePtr(svs[i], (void*) ptr, 
+                             $descriptor(T *), $shadow|$owner);
+            }
+            AV *myav = av_make(len, svs);
+            delete[] svs;
+            $result = newRV_noinc((SV*) myav);
+            sv_2mortal($result);
+            argvi++;
+        }
+        %typecheck(SWIG_TYPECHECK_VECTOR) vector<T> {
+            {
+                /* wrapped vector? */
+                std::vector< T >* v;
+                if (SWIG_ConvertPtr($input,(void **) &v, 
+                                    $&1_descriptor,0) != -1) {
+                    $1 = 1;
+                } else if (SvROK($input)) {
+                    /* native sequence? */
+                    AV *av = (AV *)SvRV($input);
+                    if (SvTYPE(av) == SVt_PVAV) {
+                        I32 len = av_len(av) + 1;
+                        if (len == 0) {
+                            /* an empty sequence can be of any type */
+                            $1 = 1;
+                        } else {
+                            /* check the first element only */
+                            T* obj;
+                            SV **tv = av_fetch(av, 0, 0);
+                            if (SWIG_ConvertPtr(*tv, (void **)&obj, 
+                                                $descriptor(T *),0) != -1)
+                                $1 = 1;
+                            else
+                                $1 = 0;
+                        }
+                    }
+                } else {
+                    $1 = 0;
+                }
+            }
+        }
+        %typecheck(SWIG_TYPECHECK_VECTOR) const vector<T>&,
+                                          const vector<T>* {
+            {
+                /* wrapped vector? */
+                std::vector< T >* v;
+                if (SWIG_ConvertPtr($input,(void **) &v, 
+                                    $1_descriptor,0) != -1) {
+                    $1 = 1;
+                } else if (SvROK($input)) {
+                    /* native sequence? */
+                    AV *av = (AV *)SvRV($input);
+                    if (SvTYPE(av) == SVt_PVAV) {
+                        I32 len = av_len(av) + 1;
+                        if (len == 0) {
+                            /* an empty sequence can be of any type */
+                            $1 = 1;
+                        } else {
+                            /* check the first element only */
+                            T* obj;
+                            SV **tv = av_fetch(av, 0, 0);
+                            if (SWIG_ConvertPtr(*tv, (void **)&obj, 
+                                                $descriptor(T *),0) != -1)
+                                $1 = 1;
+                            else
+                                $1 = 0;
+                        }
+                    }
+                } else {
+                    $1 = 0;
+                }
+            }
+        }
+      public:
+        typedef size_t size_type;
+        typedef T value_type;
+        typedef const value_type& const_reference;
+        vector(unsigned int size = 0);
+        vector(unsigned int size, const T& value);
+        vector(const vector<T> &);
+
+        unsigned int size() const;
+        bool empty() const;
+        void clear();
+        %rename(push) push_back;
+        void push_back(const T& x);
+        %extend {
+            T pop() throw (std::out_of_range) {
+                if (self->size() == 0)
+                    throw std::out_of_range("pop from empty vector");
+                T x = self->back();
+                self->pop_back();
+                return x;
+            }
+            T& 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 T& x) throw (std::out_of_range) {
+                int size = int(self->size());
+                if (i>=0 && i<size)
+                    (*self)[i] = x;
+                else
+                    throw std::out_of_range("vector index out of range");
+            }
+        }
+    };
+
+    // specializations for pointers
+    template<class T> class vector<T*> {
+        %typemap(in) vector<T*> (std::vector<T*>* v) {
+	    int res = SWIG_ConvertPtr($input,(void **) &v, $&1_descriptor,0);
+            if (SWIG_IsOK(res)){
+                $1 = *v;
+            } else if (SvROK($input)) {
+                AV *av = (AV *)SvRV($input);
+                if (SvTYPE(av) != SVt_PVAV)
+                    SWIG_croak("Type error in argument $argnum of $symname. "
+                               "Expected an array of " #T);
+                I32 len = av_len(av) + 1;
+                for (int i=0; i<len; i++) {
+		    void *v;
+		    SV **tv = av_fetch(av, i, 0);
+		    int res = SWIG_ConvertPtr(*tv, &v, $descriptor(T *),0);
+                    if (SWIG_IsOK(res)) {
+                        $1.push_back(%static_cast(v, T *));
+                    } else {
+                        SWIG_croak("Type error in argument $argnum of "
+                                   "$symname. "
+                                   "Expected an array of " #T);
+                    }
+                }
+            } else {
+                SWIG_croak("Type error in argument $argnum of $symname. "
+                           "Expected an array of " #T);
+            }
+        }
+        %typemap(in) const vector<T *>& (std::vector<T *> temp,std::vector<T *>* v),
+                     const vector<T *>* (std::vector<T *> temp,std::vector<T *>* v) {
+	    int res = SWIG_ConvertPtr($input,(void **) &v, $1_descriptor,0);
+            if (SWIG_IsOK(res)) {
+                $1 = v;
+            } else if (SvROK($input)) {
+                AV *av = (AV *)SvRV($input);
+                if (SvTYPE(av) != SVt_PVAV)
+                    SWIG_croak("Type error in argument $argnum of $symname. "
+                               "Expected an array of " #T);
+                I32 len = av_len(av) + 1;
+                for (int i=0; i<len; i++) {
+		    void *v;
+		    SV **tv = av_fetch(av, i, 0);
+		    int res = SWIG_ConvertPtr(*tv, &v, $descriptor(T *),0);
+                    if (SWIG_IsOK(res)) {
+                        temp.push_back(%static_cast(v, T *));
+                    } else {
+                        SWIG_croak("Type error in argument $argnum of "
+                                   "$symname. "
+                                   "Expected an array of " #T);
+                    }
+                }
+                $1 = &temp;
+            } else {
+                SWIG_croak("Type error in argument $argnum of $symname. "
+                           "Expected an array of " #T);
+            }
+        }
+        %typemap(out) vector<T *> {
+            size_t len = $1.size();
+            SV **svs = new SV*[len];
+            for (size_t i=0; i<len; i++) {
+                T *x = (($1_type &)$1)[i];
+                svs[i] = sv_newmortal();
+		sv_setsv(svs[i], SWIG_NewPointerObj(x, $descriptor(T *), 0));
+            }
+            AV *myav = av_make(len, svs);
+            delete[] svs;
+            $result = newRV_noinc((SV*) myav);
+            sv_2mortal($result);
+            argvi++;
+        }
+        %typecheck(SWIG_TYPECHECK_VECTOR) vector<T *> {
+            {
+                /* wrapped vector? */
+                std::vector< T *>* v;
+		int res = SWIG_ConvertPtr($input,(void **) &v, $&1_descriptor,0);
+                if (SWIG_IsOK(res)) {
+                    $1 = 1;
+                } else if (SvROK($input)) {
+                    /* native sequence? */
+                    AV *av = (AV *)SvRV($input);
+                    if (SvTYPE(av) == SVt_PVAV) {
+                        I32 len = av_len(av) + 1;
+                        if (len == 0) {
+                            /* an empty sequence can be of any type */
+                            $1 = 1;
+                        } else {
+                            /* check the first element only */
+			    void *v;
+			    SV **tv = av_fetch(av, 0, 0);
+			    int res = SWIG_ConvertPtr(*tv, &v, $descriptor(T *),0);
+                            if (SWIG_IsOK(res))
+                                $1 = 1;
+                            else
+                                $1 = 0;
+                        }
+                    }
+                } else {
+                    $1 = 0;
+                }
+            }
+        }
+        %typecheck(SWIG_TYPECHECK_VECTOR) const vector<T *>&,const vector<T *>* {
+            {
+                /* wrapped vector? */
+                std::vector< T *> *v;
+		int res = SWIG_ConvertPtr($input,%as_voidptrptr(&v), $1_descriptor,0);
+                if (SWIG_IsOK(res)) {
+                    $1 = 1;
+                } else if (SvROK($input)) {
+                    /* native sequence? */
+                    AV *av = (AV *)SvRV($input);
+                    if (SvTYPE(av) == SVt_PVAV) {
+                        I32 len = av_len(av) + 1;
+                        if (len == 0) {
+                            /* an empty sequence can be of any type */
+                            $1 = 1;
+                        } else {
+                            /* check the first element only */
+			    void *v;
+			    SV **tv = av_fetch(av, 0, 0);
+			    int res = SWIG_ConvertPtr(*tv, &v, $descriptor(T *),0);
+                            if (SWIG_IsOK(res))
+                                $1 = 1;
+                            else
+                                $1 = 0;
+                        }
+                    }
+                } else {
+                    $1 = 0;
+                }
+            }
+        }
+      public:
+        typedef size_t size_type;
+        typedef T value_type;
+        typedef const value_type& const_reference;
+        vector(unsigned int size = 0);
+        vector(unsigned int size, T *value);
+        vector(const vector<T *> &);
+
+        unsigned int size() const;
+        bool empty() const;
+        void clear();
+        %rename(push) push_back;
+        void push_back(T *x);
+        %extend {
+            T *pop() throw (std::out_of_range) {
+                if (self->size() == 0)
+                    throw std::out_of_range("pop from empty vector");
+                T *x = self->back();
+                self->pop_back();
+                return x;
+            }
+            T *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, T *x) throw (std::out_of_range) {
+                int size = int(self->size());
+                if (i>=0 && i<size)
+                    (*self)[i] = x;
+                else
+                    throw std::out_of_range("vector index out of range");
+            }
+        }
+    };
+
+
+    // specializations for built-ins
+
+    %define specialize_std_vector(T,CHECK_T,TO_T,FROM_T)
+    template<> class vector<T> {
+        %typemap(in) vector<T> (std::vector<T>* v) {
+            if (SWIG_ConvertPtr($input,(void **) &v, 
+                                $&1_descriptor,1) != -1){
+                $1 = *v;
+            } else if (SvROK($input)) {
+                AV *av = (AV *)SvRV($input);
+                if (SvTYPE(av) != SVt_PVAV)
+                    SWIG_croak("Type error in argument $argnum of $symname. "
+                               "Expected an array of " #T);
+                SV **tv;
+                I32 len = av_len(av) + 1;
+                for (int i=0; i<len; i++) {
+                    tv = av_fetch(av, i, 0);
+                    if (CHECK_T(*tv)) {
+                        $1.push_back((T)TO_T(*tv));
+                    } else {
+                        SWIG_croak("Type error in argument $argnum of "
+                                   "$symname. "
+                                   "Expected an array of " #T);
+                    }
+                }
+            } else {
+                SWIG_croak("Type error in argument $argnum of $symname. "
+                           "Expected an array of " #T);
+            }
+        }
+        %typemap(in) const vector<T>& (std::vector<T> temp,
+                                       std::vector<T>* v),
+                     const vector<T>* (std::vector<T> temp,
+                                       std::vector<T>* v) {
+            if (SWIG_ConvertPtr($input,(void **) &v, 
+                                $1_descriptor,1) != -1) {
+                $1 = v;
+            } else if (SvROK($input)) {
+                AV *av = (AV *)SvRV($input);
+                if (SvTYPE(av) != SVt_PVAV)
+                    SWIG_croak("Type error in argument $argnum of $symname. "
+                               "Expected an array of " #T);
+                SV **tv;
+                I32 len = av_len(av) + 1;
+                for (int i=0; i<len; i++) {
+                    tv = av_fetch(av, i, 0);
+                    if (CHECK_T(*tv)) {
+                        temp.push_back((T)TO_T(*tv));
+                    } else {
+                        SWIG_croak("Type error in argument $argnum of "
+                                   "$symname. "
+                                   "Expected an array of " #T);
+                    }
+                }
+                $1 = &temp;
+            } else {
+                SWIG_croak("Type error in argument $argnum of $symname. "
+                           "Expected an array of " #T);
+            }
+        }
+        %typemap(out) vector<T> {
+            size_t len = $1.size();
+            SV **svs = new SV*[len];
+            for (size_t i=0; i<len; i++) {
+                svs[i] = sv_newmortal();
+                FROM_T(svs[i], $1[i]);
+            }
+            AV *myav = av_make(len, svs);
+            delete[] svs;
+            $result = newRV_noinc((SV*) myav);
+            sv_2mortal($result);
+            argvi++;
+        }
+        %typecheck(SWIG_TYPECHECK_VECTOR) vector<T> {
+            {
+                /* wrapped vector? */
+                std::vector< T >* v;
+                if (SWIG_ConvertPtr($input,(void **) &v, 
+                                    $&1_descriptor,0) != -1) {
+                    $1 = 1;
+                } else if (SvROK($input)) {
+                    /* native sequence? */
+                    AV *av = (AV *)SvRV($input);
+                    if (SvTYPE(av) == SVt_PVAV) {
+                        I32 len = av_len(av) + 1;
+                        if (len == 0) {
+                            /* an empty sequence can be of any type */
+                            $1 = 1;
+                        } else {
+                            /* check the first element only */
+                            SV **tv = av_fetch(av, 0, 0);
+                            if (CHECK_T(*tv))
+                                $1 = 1;
+                            else
+                                $1 = 0;
+                        }
+                    }
+                } else {
+                    $1 = 0;
+                }
+            }
+        }
+        %typecheck(SWIG_TYPECHECK_VECTOR) const vector<T>&,
+                                          const vector<T>* {
+            {
+                /* wrapped vector? */
+                std::vector< T >* v;
+                if (SWIG_ConvertPtr($input,(void **) &v, 
+                                    $1_descriptor,0) != -1) {
+                    $1 = 1;
+                } else if (SvROK($input)) {
+                    /* native sequence? */
+                    AV *av = (AV *)SvRV($input);
+                    if (SvTYPE(av) == SVt_PVAV) {
+                        I32 len = av_len(av) + 1;
+                        if (len == 0) {
+                            /* an empty sequence can be of any type */
+                            $1 = 1;
+                        } else {
+                            /* check the first element only */
+                            SV **tv = av_fetch(av, 0, 0);
+                            if (CHECK_T(*tv))
+                                $1 = 1;
+                            else
+                                $1 = 0;
+                        }
+                    }
+                } else {
+                    $1 = 0;
+                }
+            }
+        }
+      public:
+        typedef size_t size_type;
+        typedef T value_type;
+        typedef const value_type& const_reference;
+        vector(unsigned int size = 0);
+        vector(unsigned int size, T value);
+        vector(const vector<T> &);
+
+        unsigned int size() const;
+        bool empty() const;
+        void clear();
+        %rename(push) push_back;
+        void push_back(T x);
+        %extend {
+            T pop() throw (std::out_of_range) {
+                if (self->size() == 0)
+                    throw std::out_of_range("pop from empty vector");
+                T x = self->back();
+                self->pop_back();
+                return x;
+            }
+            T 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, T x) throw (std::out_of_range) {
+                int size = int(self->size());
+                if (i>=0 && i<size)
+                    (*self)[i] = x;
+                else
+                    throw std::out_of_range("vector index out of range");
+            }
+        }
+    };
+    %enddef
+
+    specialize_std_vector(bool,SvIOK,SvIVX,sv_setiv);
+    specialize_std_vector(char,SvIOK,SvIVX,sv_setiv);
+    specialize_std_vector(int,SvIOK,SvIVX,sv_setiv);
+    specialize_std_vector(short,SvIOK,SvIVX,sv_setiv);
+    specialize_std_vector(long,SvIOK,SvIVX,sv_setiv);
+    specialize_std_vector(unsigned char,SvIOK,SvIVX,sv_setiv);
+    specialize_std_vector(unsigned int,SvIOK,SvIVX,sv_setiv);
+    specialize_std_vector(unsigned short,SvIOK,SvIVX,sv_setiv);
+    specialize_std_vector(unsigned long,SvIOK,SvIVX,sv_setiv);
+    specialize_std_vector(float,SvNIOK,SwigSvToNumber,sv_setnv);
+    specialize_std_vector(double,SvNIOK,SwigSvToNumber,sv_setnv);
+    specialize_std_vector(std::string,SvPOK,SwigSvToString,SwigSvFromString);
+}
+
diff --git a/share/swig/2.0.11/perl5/stl.i b/share/swig/3.0.12/perl5/stl.i
index b19eae5..b19eae5 100644
--- a/share/swig/2.0.11/perl5/stl.i
+++ b/share/swig/3.0.12/perl5/stl.i
diff --git a/share/swig/2.0.11/perl5/typemaps.i b/share/swig/3.0.12/perl5/typemaps.i
index 7d96f2a..7d96f2a 100644
--- a/share/swig/2.0.11/perl5/typemaps.i
+++ b/share/swig/3.0.12/perl5/typemaps.i
diff --git a/share/swig/3.0.12/php/const.i b/share/swig/3.0.12/php/const.i
new file mode 100644
index 0000000..d62f162
--- /dev/null
+++ b/share/swig/3.0.12/php/const.i
@@ -0,0 +1,48 @@
+/* -----------------------------------------------------------------------------
+ * const.i
+ *
+ * Typemaps for constants
+ * ----------------------------------------------------------------------------- */
+
+%typemap(consttab) int,
+                   unsigned int,
+                   short,
+                   unsigned short,
+                   long,
+                   unsigned long,
+                   unsigned char,
+                   signed char,
+                   enum SWIGTYPE
+  "SWIG_LONG_CONSTANT($symname, ($1_type)$value);";
+
+%typemap(consttab) bool
+  "SWIG_BOOL_CONSTANT($symname, ($1_type)$value);";
+
+%typemap(consttab) float,
+                   double
+  "SWIG_DOUBLE_CONSTANT($symname, $value);";
+
+%typemap(consttab) char
+  "SWIG_CHAR_CONSTANT($symname, $value);";
+
+%typemap(consttab) char *,
+                   const char *,
+                   char [],
+                   const char []
+  "SWIG_STRING_CONSTANT($symname, $value);";
+
+%typemap(consttab) SWIGTYPE *,
+                   SWIGTYPE &,
+                   SWIGTYPE &&,
+                   SWIGTYPE [] {
+  zend_constant c;
+  SWIG_SetPointerZval(&c.value, (void*)$value, $1_descriptor, 0);
+  zval_copy_ctor(&c.value);
+  c.name = zend_string_init("$symname", sizeof("$symname") - 1, 0);
+  c.flags = CONST_CS;
+  c.module_number = module_number;
+  zend_register_constant(&c);
+}
+
+/* Handled as a global variable. */
+%typemap(consttab) SWIGTYPE (CLASS::*) "";
diff --git a/share/swig/3.0.12/php/director.swg b/share/swig/3.0.12/php/director.swg
new file mode 100644
index 0000000..ea0eba8
--- /dev/null
+++ b/share/swig/3.0.12/php/director.swg
@@ -0,0 +1,170 @@
+/* -----------------------------------------------------------------------------
+ * director.swg
+ *
+ * This file contains support for director classes so that PHP proxy
+ * methods can be called from C++.
+ * ----------------------------------------------------------------------------- */
+
+#ifndef SWIG_DIRECTOR_PHP_HEADER_
+#define SWIG_DIRECTOR_PHP_HEADER_
+
+#include <string>
+#include <exception>
+#include <map>
+
+namespace Swig {
+
+  /* memory handler */
+  struct GCItem {
+    virtual ~GCItem() {
+    }
+
+    virtual int get_own() const {
+      return 0;
+    }
+  };
+
+  struct GCItem_var {
+    GCItem_var(GCItem *item = 0) : _item(item) {
+    }
+
+    GCItem_var& operator=(GCItem *item) {
+      GCItem *tmp = _item;
+      _item = item;
+      delete tmp;
+      return *this;
+    }
+
+    ~GCItem_var() {
+      delete _item;
+    }
+
+    GCItem * operator->() const {
+      return _item;
+    }
+
+    private:
+    GCItem *_item;
+  };
+
+  struct GCItem_Object : GCItem {
+    GCItem_Object(int own) : _own(own) {
+    }
+
+    virtual ~GCItem_Object() {
+    }
+
+    int get_own() const {
+      return _own;
+    }
+
+    private:
+    int _own;
+  };
+
+  template <typename Type>
+  struct GCItem_T : GCItem {
+    GCItem_T(Type *ptr) : _ptr(ptr) {
+    }
+
+    virtual ~GCItem_T() {
+      delete _ptr;
+    }
+
+    private:
+    Type *_ptr;
+  };
+
+  class Director {
+    protected:
+      // "mutable" so we can get a non-const pointer to it in const methods.
+      mutable zval swig_self;
+      typedef std::map<void *, GCItem_var> swig_ownership_map;
+      mutable swig_ownership_map swig_owner;
+    public:
+      Director(zval *self) {
+        ZVAL_COPY_VALUE(&swig_self, self);
+      }
+
+      static bool swig_is_overridden_method(const char *cname, const char *lc_fname) {
+        bool result = false;
+        zend_string * cname_str = zend_string_init(cname, strlen(cname), 0);
+        zend_class_entry *ce = zend_lookup_class(cname_str);
+        if (ce) {
+          zval * mptr = zend_hash_str_find(&ce->function_table, lc_fname, strlen(lc_fname));
+          if (mptr) {
+            // common.scope points to zend_class_entry for the declaring class,
+            // and there's only one of those per class, so we can just use a
+            // pointer compare here.
+            result = Z_FUNC_P(mptr)->common.scope != ce;
+          }
+        }
+        zend_string_release(cname_str);
+        return result;
+      }
+
+      template <typename Type>
+      void swig_acquire_ownership(Type *vptr) const {
+        if (vptr) {
+          swig_owner[vptr] = new GCItem_T<Type>(vptr);
+        }
+      }
+  };
+
+  /* base class for director exceptions */
+  class DirectorException : public std::exception {
+  protected:
+    std::string swig_msg;
+  public:
+    DirectorException(int code, const char *hdr, const char *msg) : swig_msg(hdr) {
+      if (msg && msg[0]) {
+        swig_msg += " ";
+        swig_msg += msg;
+      }
+      SWIG_ErrorCode() = code;
+      SWIG_ErrorMsg() = swig_msg.c_str();
+    }
+
+    virtual ~DirectorException() throw() {
+    }
+
+    const char *what() const throw() {
+      return swig_msg.c_str();
+    }
+
+    static void raise(int code, const char *hdr, const char *msg) {
+      throw DirectorException(code, hdr, msg);
+    }
+  };
+
+  /* attempt to call a pure virtual method via a director method */
+  class DirectorPureVirtualException : public DirectorException {
+  public:
+    DirectorPureVirtualException(const char *msg)
+      : DirectorException(E_ERROR, "SWIG director pure virtual method called", msg) {
+    }
+
+    static void raise(const char *msg) {
+      throw DirectorPureVirtualException(msg);
+    }
+  };
+
+  /* any php exception that occurs during a director method call */
+  class DirectorMethodException : public DirectorException
+  {
+  public:
+    DirectorMethodException()
+      : DirectorException(E_ERROR, "SWIG director method error", NULL) {
+    }
+
+    DirectorMethodException(const char *msg)
+      : DirectorException(E_ERROR, "SWIG director method error", msg) {
+    }
+
+    static void raise(const char *msg) {
+      throw DirectorMethodException(msg);
+    }
+  };
+}
+
+#endif
diff --git a/share/swig/2.0.11/php/factory.i b/share/swig/3.0.12/php/factory.i
index c4e082d..c4e082d 100644
--- a/share/swig/2.0.11/php/factory.i
+++ b/share/swig/3.0.12/php/factory.i
diff --git a/share/swig/3.0.12/php/globalvar.i b/share/swig/3.0.12/php/globalvar.i
new file mode 100644
index 0000000..a5fd779
--- /dev/null
+++ b/share/swig/3.0.12/php/globalvar.i
@@ -0,0 +1,294 @@
+/* -----------------------------------------------------------------------------
+ * globalvar.i
+ *
+ * Global variables - add the variable to PHP
+ * ----------------------------------------------------------------------------- */
+
+%typemap(varinit) char *
+{
+  zval z_var;
+  if ($1) {
+    ZVAL_STRING(&z_var, $1);
+  } else {
+    ZVAL_STR(&z_var, ZSTR_EMPTY_ALLOC());
+  }
+  zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
+}
+
+%typemap(varinit) char []
+{
+  zval z_var;
+  ZVAL_STRING(&z_var, $1);
+  zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
+}
+
+%typemap(varinit) int,
+	          unsigned int,
+                  unsigned short,
+                  short,
+                  unsigned short,
+                  long,
+                  unsigned long,
+                  signed char,
+                  unsigned char,
+                  enum SWIGTYPE
+{
+  zval z_var;
+  ZVAL_LONG(&z_var, (long)$1);
+  zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
+}
+
+%typemap(varinit) bool
+{
+  zval z_var;
+  ZVAL_BOOL(&z_var, ($1)?1:0);
+  zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
+}
+
+%typemap(varinit) float, double
+{
+  zval z_var;
+  ZVAL_DOUBLE(&z_var, (double)$1);
+  zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
+}
+
+%typemap(varinit) char
+{
+  zval z_var;
+  char c = $1;
+  ZVAL_STRINGL(&z_var, &c, 1);
+  zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
+}
+
+%typemap(varinit) SWIGTYPE *, SWIGTYPE []
+{
+  zval z_var;
+  SWIG_SetPointerZval(&z_var, (void*)$1, $1_descriptor, 0);
+  zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
+}
+
+%typemap(varinit) SWIGTYPE, SWIGTYPE &, SWIGTYPE &&
+{
+  zval z_var;
+  SWIG_SetPointerZval(&z_var, (void*)&$1, $&1_descriptor, 0);
+  zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
+}
+
+%typemap(varinit) char [ANY]
+{
+  zval z_var;
+  /* varinit char [ANY] */
+  ZVAL_STRINGL(&z_var, $1, $1_dim0);
+  zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
+}
+
+%typemap(varinit, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
+{
+  zval resource;
+  void * p = emalloc(sizeof($1));
+  memcpy(p, &$1, sizeof($1));
+  ZVAL_RES(&resource, zend_register_resource(p, swig_member_ptr));
+  zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &resource);
+}
+
+%typemap(varin) int, unsigned int, short, unsigned short, long, unsigned long, signed char, unsigned char,  enum SWIGTYPE
+{
+  zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
+  $1 = zval_get_long(z_var);
+}
+
+%typemap(varin) bool
+{
+  zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
+  convert_to_boolean(z_var);
+  $1 = (Z_TYPE_P(z_var) == IS_TRUE);
+}
+
+%typemap(varin) double,float
+{
+  zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
+  $1 = zval_get_double(z_var);
+}
+
+%typemap(varin) char
+{
+  zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
+  convert_to_string(z_var);
+  if ($1 != Z_STRVAL_P(z_var)[0]) {
+    $1 = Z_STRVAL_P(z_var)[0];
+  }
+}
+
+%typemap(varin) char *
+{
+  zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
+  char *s1;
+  convert_to_string(z_var);
+  s1 = Z_STRVAL_P(z_var);
+  if ((s1 == NULL) || ($1 == NULL) || strcmp(s1, $1)) {
+    if (s1)
+      $1 = estrdup(s1);
+    else
+      $1 = NULL;
+  }
+}
+
+
+%typemap(varin) SWIGTYPE []
+{
+  if($1) {
+    zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
+    SWIG_SetPointerZval(z_var, (void*)$1, $1_descriptor, $owner);
+  }
+}
+
+%typemap(varin) char [ANY]
+{
+ zval **z_var;
+ char *s1;
+
+ zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1, (void**)&z_var);
+ s1 = Z_STRVAL_P(z_var);
+ if ((s1 == NULL) || ($1 == NULL) || strcmp(s1, $1)) {
+   if (s1)
+     strncpy($1, s1, $1_dim0);
+ }
+}
+
+%typemap(varin) SWIGTYPE
+{
+  zval *z_var;
+  $&1_ltype _temp;
+
+  z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
+  if (SWIG_ConvertPtr(z_var, (void**)&_temp, $&1_descriptor, 0) < 0) {
+    SWIG_PHP_Error(E_ERROR,"Type error in value of $symname. Expected $&1_descriptor");
+  }
+
+  $1 = *($&1_ltype)_temp;
+
+}
+
+%typemap(varin) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&
+{
+  zval *z_var;
+  $1_ltype _temp;
+
+  z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
+  if (SWIG_ConvertPtr(z_var, (void **)&_temp, $1_descriptor, 0) < 0) {
+    SWIG_PHP_Error(E_ERROR,"Type error in value of $symname. Expected $&1_descriptor");
+  }
+
+  $1 = ($1_ltype)_temp;
+}
+
+%typemap(varin, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
+{
+  zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
+  void * p = (void*)zend_fetch_resource_ex(z_var, SWIG_MEMBER_PTR, swig_member_ptr);
+  memcpy(&$1, p, sizeof($1));
+}
+
+%typemap(varout) int,
+                 unsigned int,
+                 unsigned short,
+                 short,
+                 long,
+                 unsigned long,
+                 signed char,
+                 unsigned char,
+                 enum SWIGTYPE
+{
+  zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
+  if ($1 != ($1_ltype)Z_LVAL_P(z_var)) {
+    z_var->value.lval = (long)$1;
+  }
+}
+
+//SAMFIX need to cast zval->type, what if zend-hash_find fails? etc?
+%typemap(varout) bool
+{
+  zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
+  if ($1 != ($1_ltype)Z_LVAL_P(z_var)) {
+    z_var->value.lval = (long)$1;
+  }
+}
+
+%typemap(varout) double, float
+{
+  zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
+  if ($1 != ($1_ltype)Z_DVAL_P(z_var)) {
+    z_var->value.dval = (double)$1;
+  }
+}
+
+%typemap(varout) char
+{
+  zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
+  char c = $1;
+  if ($1 != Z_STRVAL_P(z_val)[0]) {
+    ZVAL_STRING(z_var, &c);
+  }
+}
+
+%typemap(varout) char *
+{
+  zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
+  const char *s1 = Z_STRVAL_P(z_var);
+  if ((s1 == NULL) || ($1 == NULL) || strcmp(s1, $1)) {
+    if (s1)
+      efree(s1);
+    if ($1) {
+      (z_var)->value.str.val = estrdup($1);
+      (z_var)->value.str.len = strlen($1) + 1;
+    } else {
+      (z_var)->value.str.val = 0;
+      (z_var)->value.str.len = 0;
+    }
+ }
+}
+
+%typemap(varout) SWIGTYPE
+{
+  zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
+  SWIG_SetPointerZval(z_var, (void*)&$1, $&1_descriptor, 0);
+}
+
+%typemap(varout) SWIGTYPE []
+{
+  if($1) {
+    zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
+    SWIG_SetPointerZval(z_var, (void*)$1, $1_descriptor, 0);
+  }
+}
+
+%typemap(varout) char [ANY]
+{
+  zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
+  const char *s1 = Z_STRVAL_P(z_var);
+deliberate error cos this code looks bogus to me
+  if ((s1 == NULL) || strcmp(s1, $1)) {
+    if ($1) {
+      (z_var)->value.str.val = estrdup($1);
+      (z_var)->value.str.len = strlen($1) + 1;
+    } else {
+      (z_var)->value.str.val = 0;
+      (z_var)->value.str.len = 0;
+    }
+  }
+}
+
+%typemap(varout) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&
+{
+  zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
+  SWIG_SetPointerZval(z_var, (void*)$1, $1_descriptor, 0);
+}
+
+%typemap(varout, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
+{
+  zval resource;
+  void * p = emalloc(sizeof($1));
+  memcpy(p, &$1, sizeof($1));
+  ZVAL_RES(&resource, zend_register_resource(p, swig_member_ptr));
+  zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &resource);
+}
diff --git a/share/swig/3.0.12/php/php.swg b/share/swig/3.0.12/php/php.swg
new file mode 100644
index 0000000..c9b9a52
--- /dev/null
+++ b/share/swig/3.0.12/php/php.swg
@@ -0,0 +1,531 @@
+/* -----------------------------------------------------------------------------
+ * php.swg
+ *
+ * PHP configuration file
+ * ----------------------------------------------------------------------------- */
+
+%runtime "swigrun.swg"  // Common C API type-checking code
+%runtime "phprun.swg"	// PHP runtime functions
+
+%include <phpinit.swg> // PHP initialization routine.
+
+%include <globalvar.i>	// Global variables.
+%include <const.i>
+
+// use %init %{ "/*code goes here*/ " %}
+// or  %minit %{ "/* code goes here*/ " %} to
+// insert code in the PHP_MINIT_FUNCTION
+#define %minit %insert("init")
+
+// use %rinit %{ "/* code goes here*/ " %} to
+// insert code in the PHP_RINIT_FUNCTION
+#define %rinit %insert("rinit")
+
+// use %shutdown %{ " /*code goes here*/ " %} to
+// insert code in the PHP_MSHUTDOWN_FUNCTION
+#define %shutdown  %insert("shutdown")
+#define %mshutdown  %insert("shutdown")
+
+// use %rshutdown %{ " /*code goes here*/" %} to
+// insert code in the PHP_RSHUTDOWN_FUNCTION
+#define %rshutdown  %insert("rshutdown")
+
+/* Typemaps for input parameters by value */
+
+%include <utils.i>
+
+%pass_by_val(bool,CONVERT_BOOL_IN);
+
+%pass_by_val(size_t, CONVERT_INT_IN);
+
+%pass_by_val(enum SWIGTYPE, CONVERT_INT_IN);
+
+%pass_by_val(signed int, CONVERT_INT_IN);
+%pass_by_val(int,CONVERT_INT_IN);
+%pass_by_val(unsigned int,CONVERT_INT_IN);
+
+%pass_by_val(signed short, CONVERT_INT_IN);
+%pass_by_val(short,CONVERT_INT_IN);
+%pass_by_val(unsigned short, CONVERT_INT_IN);
+
+%pass_by_val(signed long, CONVERT_INT_IN);
+%pass_by_val(long, CONVERT_INT_IN);
+%pass_by_val(unsigned long, CONVERT_INT_IN);
+
+%pass_by_val(signed long long, CONVERT_LONG_LONG_IN);
+%pass_by_val(long long, CONVERT_LONG_LONG_IN);
+%pass_by_val(unsigned long long, CONVERT_UNSIGNED_LONG_LONG_IN);
+
+%pass_by_val(signed char, CONVERT_INT_IN);
+%pass_by_val(char, CONVERT_CHAR_IN);
+%pass_by_val(unsigned char, CONVERT_INT_IN);
+
+%pass_by_val(float, CONVERT_FLOAT_IN);
+
+%pass_by_val(double, CONVERT_FLOAT_IN);
+
+%pass_by_val(char *, CONVERT_STRING_IN);
+%typemap(in) char *& = const char *&;
+%typemap(directorout) char *& = const char *&;
+
+// char array can be in/out, though the passed string may not be big enough...
+// so we have to size it
+%typemap(in) char[ANY]
+%{
+   convert_to_string(&$input);
+   $1 = ($1_ltype) Z_STRVAL($input);
+%}
+
+%typemap(in) (char *STRING, int LENGTH), (char *STRING, size_t LENGTH) %{
+   convert_to_string(&$input);
+   $1 = ($1_ltype) Z_STRVAL($input);
+   $2 = ($2_ltype) Z_STRLEN($input);
+%}
+
+/* Object passed by value. Convert to a pointer */
+%typemap(in) SWIGTYPE ($&1_ltype tmp)
+%{
+	if (SWIG_ConvertPtr(&$input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL) {
+          SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
+	}
+	$1 = *tmp;
+%}
+
+%typemap(directorout) SWIGTYPE ($&1_ltype tmp)
+%{
+	/* If exit was via exception, PHP NULL is returned so skip the conversion. */
+	if (!EG(exception)) {
+	  if (SWIG_ConvertPtr($input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL)
+	    SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
+	  $result = *tmp;
+	}
+%}
+
+%typemap(in) SWIGTYPE *,
+	     SWIGTYPE []
+%{
+	if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, 0) < 0) {
+            SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor");
+	}
+%}
+
+%typemap(in) SWIGTYPE &
+%{
+	if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, 0) < 0 || $1 == NULL) {
+	    SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor");
+	}
+%}
+
+%typemap(in) SWIGTYPE &&
+%{
+	if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, 0) < 0 || $1 == NULL) {
+	    SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor");
+	}
+%}
+
+%typemap(in) SWIGTYPE *const& ($*ltype temp)
+%{
+	if (SWIG_ConvertPtr(&$input, (void **) &temp, $*1_descriptor, 0) < 0) {
+            SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $*1_descriptor");
+	}
+	$1 = ($1_ltype)&temp;
+%}
+
+%typemap(in) SWIGTYPE *DISOWN
+%{
+  if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, SWIG_POINTER_DISOWN ) < 0) {
+    SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
+  }
+%}
+
+%typemap(argout) SWIGTYPE *,
+                 SWIGTYPE [],
+                 SWIGTYPE &,
+                 SWIGTYPE &&;
+
+%typemap(in) void *
+%{
+	if (SWIG_ConvertPtr(&$input, (void **) &$1, 0, 0) < 0) {
+	  /* Allow NULL from php for void* */
+	  if (Z_ISNULL($input)) $1=0;
+	  else
+            SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
+	}
+%}
+
+/* Special case when void* is passed by reference so it can be made to point
+   to opaque api structs */
+%typemap(in) void ** ($*1_ltype ptr, int force),
+             void *& ($*1_ltype ptr, int force)
+{
+  /* If they pass NULL by reference, make it into a void*
+     This bit should go in arginit if arginit support init-ing scripting args */
+  if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, 0) < 0) {
+    /* So... we didn't get a ref or ptr, but we'll accept NULL by reference */
+    if (!(Z_ISREF($input) && Z_ISNULL_P(Z_REFVAL($input)))) {
+      /* wasn't a pre/ref/thing, OR anything like an int thing */
+      SWIG_PHP_Error(E_ERROR, "Type error in argument $arg of $symname.");
+    }
+  }
+  force=0;
+  if (arg1==NULL) {
+#ifdef __cplusplus
+    ptr=new $*1_ltype();
+#else
+    ptr=($*1_ltype) calloc(1,sizeof($*1_ltype));
+#endif
+    $1=&ptr;
+    /* have to passback arg$arg too */
+    force=1;
+  }
+}
+%typemap(argout) void **,
+                 void *&
+%{
+  if (force$argnum) {
+    SWIG_SetPointerZval(&$input, (void*) ptr$argnum, $*1_descriptor, 1);
+  }
+%}
+
+/* Typemap for output values */
+
+%typemap(out) int,
+              unsigned int,
+              short,
+              unsigned short,
+              long,
+              unsigned long,
+              signed char,
+              unsigned char,
+              bool,
+              size_t
+%{
+  RETVAL_LONG($1);
+%}
+
+%typemap(out) enum SWIGTYPE
+%{
+  RETVAL_LONG((long)$1);
+%}
+
+%typemap(out) long long
+%{
+  if ((long long)LONG_MIN <= $1 && $1 <= (long long)LONG_MAX) {
+    RETVAL_LONG((long)($1));
+  } else {
+    char temp[256];
+    sprintf(temp, "%lld", (long long)$1);
+    RETVAL_STRING(temp);
+  }
+%}
+%typemap(out) unsigned long long
+%{
+  if ($1 <= (unsigned long long)LONG_MAX) {
+    RETVAL_LONG((long)($1));
+  } else {
+    char temp[256];
+    sprintf(temp, "%llu", (unsigned long long)$1);
+    RETVAL_STRING(temp);
+  }
+%}
+
+%typemap(out) const int &,
+              const unsigned int &,
+              const short &,
+              const unsigned short &,
+              const long &,
+              const unsigned long &,
+              const signed char &,
+              const unsigned char &,
+              const bool &,
+              const size_t &
+%{
+  RETVAL_LONG(*$1);
+%}
+
+%typemap(out) const enum SWIGTYPE &
+%{
+  RETVAL_LONG((long)*$1);
+%}
+
+%typemap(out) const enum SWIGTYPE &&
+%{
+  RETVAL_LONG((long)*$1);
+%}
+
+%typemap(out) const long long &
+%{
+  if ((long long)LONG_MIN <= *$1 && *$1 <= (long long)LONG_MAX) {
+    RETVAL_LONG((long)(*$1));
+  } else {
+    char temp[256];
+    sprintf(temp, "%lld", (long long)(*$1));
+    RETVAL_STRING(temp);
+  }
+%}
+%typemap(out) const unsigned long long &
+%{
+  if (*$1 <= (unsigned long long)LONG_MAX) {
+    RETVAL_LONG((long)(*$1));
+  } else {
+    char temp[256];
+    sprintf(temp, "%llu", (unsigned long long)(*$1));
+    RETVAL_STRING(temp);
+  }
+%}
+
+%typemap(directorin) int,
+              unsigned int,
+              short,
+              unsigned short,
+              long,
+              unsigned long,
+              signed char,
+              unsigned char,
+              size_t,
+              enum SWIGTYPE
+%{
+  ZVAL_LONG($input,$1);
+%}
+
+%typemap(directorin) enum SWIGTYPE
+%{
+  ZVAL_LONG($input, (long)$1_name);
+%}
+
+%typemap(directorin) char *, char []
+%{
+    if(!$1) {
+      ZVAL_NULL($input);
+    } else {
+      ZVAL_STRING($input, (const char*)$1);
+    }
+%}
+
+%typemap(out) bool
+%{
+  RETVAL_BOOL(($1) ? 1 : 0);
+%}
+
+%typemap(out) const bool &
+%{
+  RETVAL_BOOL((*$1) ? 1 : 0);
+%}
+
+%typemap(directorin) bool
+%{
+  ZVAL_BOOL($input, ($1) ? 1 : 0);
+%}
+
+%typemap(out) float,
+              double
+%{
+  RETVAL_DOUBLE($1);
+%}
+
+%typemap(out) const float &,
+              const double &
+%{
+  RETVAL_DOUBLE(*$1);
+%}
+
+%typemap(directorin) float,
+                     double
+%{
+  ZVAL_DOUBLE($input, $1);
+%}
+
+%typemap(out) char
+%{
+  RETVAL_STRINGL(&$1, 1);
+%}
+
+%typemap(out) const char &
+%{
+  RETVAL_STRINGL(&*$1, 1);
+%}
+
+%typemap(out) char *,
+              char []
+%{
+  if (!$1) {
+    RETVAL_NULL();
+  } else {
+    RETVAL_STRING((const char *)$1);
+  }
+%}
+
+%typemap(out) char *&
+%{
+  if (!*$1) {
+    RETVAL_NULL();
+  } else {
+    RETVAL_STRING((const char *)*$1);
+  }
+%}
+
+%typemap(out) SWIGTYPE *,
+              SWIGTYPE [],
+              SWIGTYPE &,
+              SWIGTYPE &&
+%{
+  SWIG_SetPointerZval(return_value, (void *)$1, $1_descriptor, $owner);
+%}
+
+%typemap(out) SWIGTYPE *const&
+%{
+  SWIG_SetPointerZval(return_value, (void *)*$1, $*1_descriptor, $owner);
+%}
+
+%typemap(directorin) SWIGTYPE *,
+                     SWIGTYPE [],
+                     SWIGTYPE &,
+                     SWIGTYPE &&
+%{
+  SWIG_SetPointerZval($input, (void *)&$1, $1_descriptor, ($owner)|2);
+%}
+
+%typemap(out, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
+{
+  void * p = emalloc(sizeof($1));
+  memcpy(p, &$1, sizeof($1));
+  RETVAL_RES(zend_register_resource(p, swig_member_ptr));
+}
+
+%typemap(in, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
+{
+  void * p = (void*)zend_fetch_resource_ex(&$input, SWIG_MEMBER_PTR, swig_member_ptr);
+  memcpy(&$1, p, sizeof($1));
+}
+
+%typemap(out) SWIGTYPE *DYNAMIC,
+              SWIGTYPE &DYNAMIC
+{
+  swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor, (void **) &$1);
+  SWIG_SetPointerZval(return_value, (void *)$1, ty, $owner);
+}
+
+%typemap(out) SWIGTYPE
+#ifdef __cplusplus
+{
+  $&1_ltype resultobj = new $1_ltype((const $1_ltype &) $1);
+  SWIG_SetPointerZval(return_value, (void *)resultobj, $&1_descriptor, 1);
+}
+#else
+{
+  $&1_ltype resultobj = ($&1_ltype) emalloc(sizeof($1_type));
+  memcpy(resultobj, &$1, sizeof($1_type));
+  SWIG_SetPointerZval(return_value, (void *)resultobj, $&1_descriptor, 1);
+}
+#endif
+
+%typemap(directorin) SWIGTYPE
+%{
+  SWIG_SetPointerZval($input, SWIG_as_voidptr(new $1_ltype((const $1_ltype &)$1)), $&1_descriptor, 1|2);
+%}
+
+%typemap(out) void "";
+
+%typemap(out) char [ANY]
+{
+  int len = 0;
+  while (len < $1_dim0 && $1[len]) ++len;
+  RETVAL_STRINGL($1, len);
+}
+
+// This typecheck does hard checking for proper argument type.  If you want
+// an argument to be converted from a different PHP type, you must convert
+// it yourself before passing it (e.g. (string)4.7 or (int)"6").
+%define %php_typecheck(_type,_prec,is)
+%typemap(typecheck,precedence=_prec) _type, const _type &
+ " $1 = (Z_TYPE($input) == is);"
+%enddef
+
+// Like %php_typecheck but allows either of two values.
+%define %php_typecheck2(_type,_prec,is1,is2)
+%typemap(typecheck,precedence=_prec) _type, const _type &
+ " $1 = (Z_TYPE($input) == is1 || Z_TYPE($input) == is2);"
+%enddef
+
+%php_typecheck(int,SWIG_TYPECHECK_INTEGER,IS_LONG)
+%php_typecheck(unsigned int,SWIG_TYPECHECK_UINT32,IS_LONG)
+%php_typecheck(short,SWIG_TYPECHECK_INT16,IS_LONG)
+%php_typecheck(unsigned short,SWIG_TYPECHECK_UINT16,IS_LONG)
+%php_typecheck(long,SWIG_TYPECHECK_INT32,IS_LONG)
+%php_typecheck(unsigned long,SWIG_TYPECHECK_UINT32,IS_LONG)
+%php_typecheck(long long,SWIG_TYPECHECK_INT64,IS_LONG)
+%php_typecheck(unsigned long long,SWIG_TYPECHECK_UINT64,IS_LONG)
+%php_typecheck(signed char,SWIG_TYPECHECK_INT8,IS_LONG)
+%php_typecheck(unsigned char,SWIG_TYPECHECK_UINT8,IS_LONG)
+%php_typecheck(size_t,SWIG_TYPECHECK_SIZE,IS_LONG)
+%php_typecheck(enum SWIGTYPE,SWIG_TYPECHECK_INTEGER,IS_LONG)
+%php_typecheck2(bool,SWIG_TYPECHECK_BOOL,IS_TRUE,IS_FALSE)
+%php_typecheck(float,SWIG_TYPECHECK_FLOAT,IS_DOUBLE)
+%php_typecheck(double,SWIG_TYPECHECK_DOUBLE,IS_DOUBLE)
+%php_typecheck(char,SWIG_TYPECHECK_CHAR,IS_STRING)
+
+%typemap(typecheck,precedence=SWIG_TYPECHECK_STRING) char *, char *&, char []
+ " $1 = (Z_TYPE($input) == IS_STRING); "
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE
+{
+  void *tmp;
+  _v = (SWIG_ConvertPtr(&$input, (void **)&tmp, $&1_descriptor, 0) >= 0);
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER)
+             SWIGTYPE *,
+             SWIGTYPE [],
+             SWIGTYPE &,
+             SWIGTYPE &&,
+             SWIGTYPE *const&
+{
+  void *tmp;
+  _v = (SWIG_ConvertPtr(&$input, (void**)&tmp, $1_descriptor, 0) >= 0);
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *const&
+{
+  void *tmp;
+  _v = (SWIG_ConvertPtr(&$input, (void**)&tmp, $*1_descriptor, 0) >= 0);
+}
+
+%typecheck(SWIG_TYPECHECK_VOIDPTR) void *
+{
+  void *tmp;
+  _v = (SWIG_ConvertPtr(&$input, (void**)&tmp, 0, 0) >= 0);
+}
+
+/* Exception handling */
+
+%typemap(throws) int,
+                 long,
+                 short,
+                 unsigned int,
+                 unsigned long,
+                 unsigned short %{
+  zend_throw_exception(NULL, "C++ $1_type exception thrown", $1);
+  return;
+%}
+
+%typemap(throws) SWIGTYPE, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE *, SWIGTYPE [], SWIGTYPE [ANY] %{
+  (void)$1;
+  zend_throw_exception(NULL, "C++ $1_type exception thrown", 0);
+  return;
+%}
+
+%typemap(throws) char * %{
+  zend_throw_exception(NULL, $1, 0);
+  return;
+%}
+
+/* Array reference typemaps */
+%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) }
+
+/* const pointers */
+%apply SWIGTYPE * { SWIGTYPE *const }
+
+
+/* php keywords */
+%include <phpkw.swg>
diff --git a/share/swig/3.0.12/php/phpinit.swg b/share/swig/3.0.12/php/phpinit.swg
new file mode 100644
index 0000000..1f252d1
--- /dev/null
+++ b/share/swig/3.0.12/php/phpinit.swg
@@ -0,0 +1,25 @@
+
+/* ------------------------------------------------------------
+ * The start of the PHP initialization function 
+ * ------------------------------------------------------------ */
+
+%insert(init) "swiginit.swg"
+
+%init %{
+SWIG_php_minit {
+    SWIG_InitializeModule(0);
+%}
+
+%fragment("swig_php_init_member_ptr2", "header") %{
+#define SWIG_MEMBER_PTR "CLASS::*"
+
+static void swig_member_ptr_dtor(zend_resource *res) {
+  efree(res->ptr);
+}
+
+static int swig_member_ptr = 0;
+%}
+
+%fragment("swig_php_init_member_ptr", "init", fragment="swig_php_init_member_ptr2") %{
+    swig_member_ptr = zend_register_list_destructors_ex(swig_member_ptr_dtor, NULL, SWIG_MEMBER_PTR, module_number);
+%}
diff --git a/share/swig/3.0.12/php/phpkw.swg b/share/swig/3.0.12/php/phpkw.swg
new file mode 100644
index 0000000..db451f9
--- /dev/null
+++ b/share/swig/3.0.12/php/phpkw.swg
@@ -0,0 +1,881 @@
+/* -----------------------------------------------------------------------------
+ * phpkw.swg
+ * ----------------------------------------------------------------------------- */
+
+/* Keyword (case insensitive) */
+#define PHPKW(x) %keywordwarn("'" `x` "' is a PHP keyword, renaming to 'c_" `x` "'",sourcefmt="%(lower)s",rename="c_%s") `x`
+
+/* Class (case insensitive) */
+#define PHPCN(x) %keywordwarn("'" `x` "' is a PHP reserved class name, renaming to 'c_" `x` "'",%$isclass,sourcefmt="%(lower)s",rename="c_%s") `x`
+
+/* Constant (case insensitive) */
+#define PHPBN1a(x) %namewarn(%warningmsg(SWIGWARN_PARSE_BUILTIN_NAME, "enum conflicts with a built-in constant '"`x`"' in PHP"),%$isenumitem,sourcefmt="%(lower)s") `x`
+#define PHPBN1b(x) %namewarn(%warningmsg(SWIGWARN_PARSE_BUILTIN_NAME, "constant conflicts with a built-in constant '"`x`"' in PHP"),%$isconstant,sourcefmt="%(lower)s") `x`
+%define PHPBN1(X)
+ PHPBN1a(X); PHPBN1b(X)
+%enddef
+
+/* Constant (case sensitive) */
+#define PHPBN2a(x) %namewarn(%warningmsg(SWIGWARN_PARSE_BUILTIN_NAME, "enum conflicts with a built-in constant '"`x`"' in PHP"),%$isenumitem) `x`
+#define PHPBN2b(x) %namewarn(%warningmsg(SWIGWARN_PARSE_BUILTIN_NAME, "constant conflicts with a built-in constant '"`x`"' in PHP"),%$isconstant) `x`
+%define PHPBN2(X)
+ PHPBN2a(X); PHPBN2b(X)
+%enddef
+
+#define PHPFN(x) %keywordwarn("'" `x` "' is a PHP built-in function, renaming to 'c_" `x` "'",sourcefmt="%(lower)s",%$isfunction,%$not %$ismember,rename="c_%s") `x`
+
+/* From: http://php.net/manual/en/reserved.keywords.php
+ * "You cannot use any of the following words as constants, class names,
+ * function or method names. Using them as variable names is generally OK, but
+ * could lead to confusion."
+ */
+/* Check is case insensitive - these *MUST* be listed in lower case here */
+PHPKW(__halt_compiler);
+PHPKW(abstract);
+PHPKW(and);
+PHPKW(array);
+PHPKW(as);
+PHPKW(break);
+PHPKW(callable); // As of PHP 5.4
+PHPKW(case);
+PHPKW(catch);
+PHPKW(class);
+PHPKW(clone);
+PHPKW(const);
+PHPKW(continue);
+PHPKW(declare);
+PHPKW(default);
+PHPKW(die); // "Language construct"
+PHPKW(do);
+PHPKW(echo); // "Language construct"
+PHPKW(else);
+PHPKW(elseif);
+PHPKW(empty); // "Language construct"
+PHPKW(enddeclare);
+PHPKW(endfor);
+PHPKW(endforeach);
+PHPKW(endif);
+PHPKW(endswitch);
+PHPKW(endwhile);
+PHPKW(eval); // "Language construct"
+PHPKW(exit); // "Language construct"
+PHPKW(extends);
+PHPKW(final);
+PHPKW(finally); // As of PHP 5.5
+PHPKW(for);
+PHPKW(foreach);
+PHPKW(function);
+PHPKW(global);
+PHPKW(goto); // As of PHP 5.3
+PHPKW(if);
+PHPKW(implements);
+PHPKW(include); // "Language construct"
+PHPKW(include_once); // "Language construct"
+PHPKW(instanceof);
+PHPKW(insteadof); // As of PHP 5.4
+PHPKW(interface);
+PHPKW(isset); // "Language construct"
+PHPKW(list); // "Language construct"
+PHPKW(namespace); // As of PHP 5.3
+PHPKW(new);
+PHPKW(or);
+PHPKW(print); // "Language construct"
+PHPKW(private);
+PHPKW(protected);
+PHPKW(public);
+PHPKW(require); // "Language construct"
+PHPKW(require_once); // "Language construct"
+PHPKW(return); // "Language construct"
+PHPKW(static);
+PHPKW(switch);
+PHPKW(throw);
+PHPKW(trait); // As of PHP 5.4
+PHPKW(try);
+PHPKW(unset); // "Language construct"
+PHPKW(use);
+PHPKW(var);
+PHPKW(while);
+PHPKW(xor);
+PHPKW(yield); // As of PHP 5.5
+
+// Compile-time "magic" constants
+// From: http://php.net/manual/en/reserved.keywords.php
+// also at: http://php.net/manual/en/language.constants.predefined.php
+/* These *MUST* be listed in lower case here */
+PHPKW(__class__);
+PHPKW(__dir__); // As of PHP 5.3
+PHPKW(__file__);
+PHPKW(__function__);
+PHPKW(__line__);
+PHPKW(__method__);
+PHPKW(__namespace__); // As of PHP 5.3
+PHPKW(__trait__); // As of PHP 5.4
+
+/* We classify these as built-in names since they conflict, but PHP still runs */
+
+/* Predefined case-insensitive constants */
+/* These *MUST* be listed in lower case here */
+PHPBN1(null);
+PHPBN1(true);
+PHPBN1(false);
+
+/* "Core Predefined Constants" from http://php.net/manual/en/reserved.constants.php */
+/* These are case sensitive */
+PHPBN2(PHP_VERSION);
+PHPBN2(PHP_MAJOR_VERSION); // As of PHP 5.2.7
+PHPBN2(PHP_MINOR_VERSION); // As of PHP 5.2.7
+PHPBN2(PHP_RELEASE_VERSION); // As of PHP 5.2.7
+PHPBN2(PHP_VERSION_ID); // As of PHP 5.2.7
+PHPBN2(PHP_EXTRA_VERSION); // As of PHP 5.2.7
+PHPBN2(PHP_ZTS); // As of PHP 5.2.7
+PHPBN2(PHP_DEBUG); // As of PHP 5.2.7
+PHPBN2(PHP_MAXPATHLEN); // As of PHP 5.3.0
+PHPBN2(PHP_OS);
+PHPBN2(PHP_SAPI);
+PHPBN2(PHP_EOL); // As of PHP 5.0.2
+PHPBN2(PHP_INT_MAX); // As of PHP 5.0.5
+PHPBN2(PHP_INT_SIZE); // As of PHP 5.0.5
+PHPBN2(DEFAULT_INCLUDE_PATH);
+PHPBN2(PEAR_INSTALL_DIR);
+PHPBN2(PEAR_EXTENSION_DIR);
+PHPBN2(PHP_EXTENSION_DIR);
+PHPBN2(PHP_PREFIX);
+PHPBN2(PHP_BINDIR);
+PHPBN2(PHP_BINARY); // As of PHP 5.4
+PHPBN2(PHP_MANDIR); // As of PHP 5.3.7
+PHPBN2(PHP_LIBDIR);
+PHPBN2(PHP_DATADIR);
+PHPBN2(PHP_SYSCONFDIR);
+PHPBN2(PHP_LOCALSTATEDIR);
+PHPBN2(PHP_CONFIG_FILE_PATH);
+PHPBN2(PHP_CONFIG_FILE_SCAN_DIR);
+PHPBN2(PHP_SHLIB_SUFFIX);
+PHPBN2(E_ERROR);
+PHPBN2(E_WARNING);
+PHPBN2(E_PARSE);
+PHPBN2(E_NOTICE);
+PHPBN2(E_CORE_ERROR);
+PHPBN2(E_CORE_WARNING);
+PHPBN2(E_COMPILE_ERROR);
+PHPBN2(E_COMPILE_WARNING);
+PHPBN2(E_USER_ERROR);
+PHPBN2(E_USER_WARNING);
+PHPBN2(E_USER_NOTICE);
+PHPBN2(E_DEPRECATED); // As of PHP 5.3.0
+PHPBN2(E_USER_DEPRECATED); // As of PHP 5.3.0
+PHPBN2(E_ALL);
+PHPBN2(E_STRICT);
+PHPBN2(__COMPILER_HALT_OFFSET__); // As of PHP 5.1.0
+// TRUE, FALSE, NULL are listed on the same page, but are actually
+// case-insensitive, whereas all the other constants listed there seem to be
+// case-sensitive, so we handle TRUE, FALSE, NULL in PHPBN1.
+PHPBN2(PHP_OUTPUT_HANDLER_START);
+PHPBN2(PHP_OUTPUT_HANDLER_CONT);
+PHPBN2(PHP_OUTPUT_HANDLER_END);
+/* These don't actually seem to be set (tested on Linux, I guess they're
+ * Windows only?) */
+PHPBN2(PHP_WINDOWS_NT_DOMAIN_CONTROLLER); // As of PHP 5.3
+PHPBN2(PHP_WINDOWS_NT_SERVER); // As of PHP 5.3
+PHPBN2(PHP_WINDOWS_NT_WORKSTATION); // As of PHP 5.3
+PHPBN2(PHP_WINDOWS_VERSION_BUILD); // As of PHP 5.3
+PHPBN2(PHP_WINDOWS_VERSION_MAJOR); // As of PHP 5.3
+PHPBN2(PHP_WINDOWS_VERSION_MINOR); // As of PHP 5.3
+PHPBN2(PHP_WINDOWS_VERSION_PLATFORM); // As of PHP 5.3
+PHPBN2(PHP_WINDOWS_VERSION_PRODUCTTYPE); // As of PHP 5.3
+PHPBN2(PHP_WINDOWS_VERSION_SP_MAJOR); // As of PHP 5.3
+PHPBN2(PHP_WINDOWS_VERSION_SP_MINOR); // As of PHP 5.3
+PHPBN2(PHP_WINDOWS_VERSION_SUITEMASK); // As of PHP 5.3
+/* "Standard Predefined Constants" from http://php.net/manual/en/reserved.constants.php */
+PHPBN2(EXTR_OVERWRITE);
+PHPBN2(EXTR_SKIP);
+PHPBN2(EXTR_PREFIX_SAME);
+PHPBN2(EXTR_PREFIX_ALL);
+PHPBN2(EXTR_PREFIX_INVALID);
+PHPBN2(EXTR_PREFIX_IF_EXISTS);
+PHPBN2(EXTR_IF_EXISTS);
+PHPBN2(SORT_ASC);
+PHPBN2(SORT_DESC);
+PHPBN2(SORT_REGULAR);
+PHPBN2(SORT_NUMERIC);
+PHPBN2(SORT_STRING);
+PHPBN2(CASE_LOWER);
+PHPBN2(CASE_UPPER);
+PHPBN2(COUNT_NORMAL);
+PHPBN2(COUNT_RECURSIVE);
+PHPBN2(ASSERT_ACTIVE);
+PHPBN2(ASSERT_CALLBACK);
+PHPBN2(ASSERT_BAIL);
+PHPBN2(ASSERT_WARNING);
+PHPBN2(ASSERT_QUIET_EVAL);
+PHPBN2(CONNECTION_ABORTED);
+PHPBN2(CONNECTION_NORMAL);
+PHPBN2(CONNECTION_TIMEOUT);
+PHPBN2(INI_USER);
+PHPBN2(INI_PERDIR);
+PHPBN2(INI_SYSTEM);
+PHPBN2(INI_ALL);
+PHPBN2(INI_SCANNER_NORMAL); // As of PHP 5.3
+PHPBN2(INI_SCANNER_RAW); // As of PHP 5.3
+PHPBN2(M_E);
+PHPBN2(M_LOG2E);
+PHPBN2(M_LOG10E);
+PHPBN2(M_LN2);
+PHPBN2(M_LN10);
+PHPBN2(M_PI);
+PHPBN2(M_PI_2);
+PHPBN2(M_PI_4);
+PHPBN2(M_1_PI);
+PHPBN2(M_2_PI);
+PHPBN2(M_2_SQRTPI);
+PHPBN2(M_SQRT2);
+PHPBN2(M_SQRT1_2);
+PHPBN2(M_EULER); // As of PHP 5.2
+PHPBN2(M_LNPI); // As of PHP 5.2
+PHPBN2(M_SQRT3); // As of PHP 5.2
+PHPBN2(M_SQRTPI); // As of PHP 5.2
+PHPBN2(CRYPT_SALT_LENGTH);
+PHPBN2(CRYPT_STD_DES);
+PHPBN2(CRYPT_EXT_DES);
+PHPBN2(CRYPT_MD5);
+PHPBN2(CRYPT_BLOWFISH);
+PHPBN2(DIRECTORY_SEPARATOR);
+PHPBN2(SEEK_SET);
+PHPBN2(SEEK_CUR);
+PHPBN2(SEEK_END);
+PHPBN2(LOCK_SH);
+PHPBN2(LOCK_EX);
+PHPBN2(LOCK_UN);
+PHPBN2(LOCK_NB);
+PHPBN2(HTML_SPECIALCHARS);
+PHPBN2(HTML_ENTITIES);
+PHPBN2(ENT_COMPAT);
+PHPBN2(ENT_QUOTES);
+PHPBN2(ENT_NOQUOTES);
+PHPBN2(INFO_GENERAL);
+PHPBN2(INFO_CREDITS);
+PHPBN2(INFO_CONFIGURATION);
+PHPBN2(INFO_MODULES);
+PHPBN2(INFO_ENVIRONMENT);
+PHPBN2(INFO_VARIABLES);
+PHPBN2(INFO_LICENSE);
+PHPBN2(INFO_ALL);
+PHPBN2(CREDITS_GROUP);
+PHPBN2(CREDITS_GENERAL);
+PHPBN2(CREDITS_SAPI);
+PHPBN2(CREDITS_MODULES);
+PHPBN2(CREDITS_DOCS);
+PHPBN2(CREDITS_FULLPAGE);
+PHPBN2(CREDITS_QA);
+PHPBN2(CREDITS_ALL);
+PHPBN2(STR_PAD_LEFT);
+PHPBN2(STR_PAD_RIGHT);
+PHPBN2(STR_PAD_BOTH);
+PHPBN2(PATHINFO_DIRNAME);
+PHPBN2(PATHINFO_BASENAME);
+PHPBN2(PATHINFO_EXTENSION);
+PHPBN2(PATHINFO_FILENAME); // As of PHP 5.2
+PHPBN2(PATH_SEPARATOR);
+PHPBN2(CHAR_MAX);
+PHPBN2(LC_CTYPE);
+PHPBN2(LC_NUMERIC);
+PHPBN2(LC_TIME);
+PHPBN2(LC_COLLATE);
+PHPBN2(LC_MONETARY);
+PHPBN2(LC_ALL);
+PHPBN2(LC_MESSAGES);
+PHPBN2(ABDAY_1);
+PHPBN2(ABDAY_2);
+PHPBN2(ABDAY_3);
+PHPBN2(ABDAY_4);
+PHPBN2(ABDAY_5);
+PHPBN2(ABDAY_6);
+PHPBN2(ABDAY_7);
+PHPBN2(DAY_1);
+PHPBN2(DAY_2);
+PHPBN2(DAY_3);
+PHPBN2(DAY_4);
+PHPBN2(DAY_5);
+PHPBN2(DAY_6);
+PHPBN2(DAY_7);
+PHPBN2(ABMON_1);
+PHPBN2(ABMON_2);
+PHPBN2(ABMON_3);
+PHPBN2(ABMON_4);
+PHPBN2(ABMON_5);
+PHPBN2(ABMON_6);
+PHPBN2(ABMON_7);
+PHPBN2(ABMON_8);
+PHPBN2(ABMON_9);
+PHPBN2(ABMON_10);
+PHPBN2(ABMON_11);
+PHPBN2(ABMON_12);
+PHPBN2(MON_1);
+PHPBN2(MON_2);
+PHPBN2(MON_3);
+PHPBN2(MON_4);
+PHPBN2(MON_5);
+PHPBN2(MON_6);
+PHPBN2(MON_7);
+PHPBN2(MON_8);
+PHPBN2(MON_9);
+PHPBN2(MON_10);
+PHPBN2(MON_11);
+PHPBN2(MON_12);
+PHPBN2(AM_STR);
+PHPBN2(PM_STR);
+PHPBN2(D_T_FMT);
+PHPBN2(D_FMT);
+PHPBN2(T_FMT);
+PHPBN2(T_FMT_AMPM);
+PHPBN2(ERA);
+PHPBN2(ERA_YEAR);
+PHPBN2(ERA_D_T_FMT);
+PHPBN2(ERA_D_FMT);
+PHPBN2(ERA_T_FMT);
+PHPBN2(ALT_DIGITS);
+PHPBN2(INT_CURR_SYMBOL);
+PHPBN2(CURRENCY_SYMBOL);
+PHPBN2(CRNCYSTR);
+PHPBN2(MON_DECIMAL_POINT);
+PHPBN2(MON_THOUSANDS_SEP);
+PHPBN2(MON_GROUPING);
+PHPBN2(POSITIVE_SIGN);
+PHPBN2(NEGATIVE_SIGN);
+PHPBN2(INT_FRAC_DIGITS);
+PHPBN2(FRAC_DIGITS);
+PHPBN2(P_CS_PRECEDES);
+PHPBN2(P_SEP_BY_SPACE);
+PHPBN2(N_CS_PRECEDES);
+PHPBN2(N_SEP_BY_SPACE);
+PHPBN2(P_SIGN_POSN);
+PHPBN2(N_SIGN_POSN);
+PHPBN2(DECIMAL_POINT);
+PHPBN2(RADIXCHAR);
+PHPBN2(THOUSANDS_SEP);
+PHPBN2(THOUSEP);
+PHPBN2(GROUPING);
+PHPBN2(YESEXPR);
+PHPBN2(NOEXPR);
+PHPBN2(YESSTR);
+PHPBN2(NOSTR);
+PHPBN2(CODESET);
+PHPBN2(LOG_EMERG);
+PHPBN2(LOG_ALERT);
+PHPBN2(LOG_CRIT);
+PHPBN2(LOG_ERR);
+PHPBN2(LOG_WARNING);
+PHPBN2(LOG_NOTICE);
+PHPBN2(LOG_INFO);
+PHPBN2(LOG_DEBUG);
+PHPBN2(LOG_KERN);
+PHPBN2(LOG_USER);
+PHPBN2(LOG_MAIL);
+PHPBN2(LOG_DAEMON);
+PHPBN2(LOG_AUTH);
+PHPBN2(LOG_SYSLOG);
+PHPBN2(LOG_LPR);
+PHPBN2(LOG_NEWS);
+PHPBN2(LOG_UUCP);
+PHPBN2(LOG_CRON);
+PHPBN2(LOG_AUTHPRIV);
+PHPBN2(LOG_LOCAL0);
+PHPBN2(LOG_LOCAL1);
+PHPBN2(LOG_LOCAL2);
+PHPBN2(LOG_LOCAL3);
+PHPBN2(LOG_LOCAL4);
+PHPBN2(LOG_LOCAL5);
+PHPBN2(LOG_LOCAL6);
+PHPBN2(LOG_LOCAL7);
+PHPBN2(LOG_PID);
+PHPBN2(LOG_CONS);
+PHPBN2(LOG_ODELAY);
+PHPBN2(LOG_NDELAY);
+PHPBN2(LOG_NOWAIT);
+PHPBN2(LOG_PERROR);
+
+/* Added in PHP 5.2 */
+PHPBN2(PREG_BACKTRACK_LIMIT_ERROR);
+PHPBN2(PREG_BAD_UTF8_ERROR);
+PHPBN2(PREG_INTERNAL_ERROR);
+PHPBN2(PREG_NO_ERROR);
+PHPBN2(PREG_RECURSION_LIMIT_ERROR);
+PHPBN2(UPLOAD_ERR_EXTENSION);
+PHPBN2(STREAM_SHUT_RD);
+PHPBN2(STREAM_SHUT_WR);
+PHPBN2(STREAM_SHUT_RDWR);
+PHPBN2(CURLE_FILESIZE_EXCEEDED);
+PHPBN2(CURLE_FTP_SSL_FAILED);
+PHPBN2(CURLE_LDAP_INVALID_URL);
+PHPBN2(CURLFTPAUTH_DEFAULT);
+PHPBN2(CURLFTPAUTH_SSL);
+PHPBN2(CURLFTPAUTH_TLS);
+PHPBN2(CURLFTPSSL_ALL);
+PHPBN2(CURLFTPSSL_CONTROL);
+PHPBN2(CURLFTPSSL_NONE);
+PHPBN2(CURLFTPSSL_TRY);
+PHPBN2(CURLOPT_FTP_SSL);
+PHPBN2(CURLOPT_FTPSSLAUTH);
+PHPBN2(CURLOPT_TCP_NODELAY); // Added in PHP 5.2.1
+PHPBN2(CURLOPT_TIMEOUT_MS); // Added in PHP 5.2.3
+PHPBN2(CURLOPT_CONNECTTIMEOUT_MS); // Added in PHP 5.2.3
+PHPBN2(GMP_VERSION); // Added in PHP 5.2.2
+PHPBN2(SWFTEXTFIELD_USEFONT);
+PHPBN2(SWFTEXTFIELD_AUTOSIZE);
+PHPBN2(SWF_SOUND_NOT_COMPRESSED);
+PHPBN2(SWF_SOUND_ADPCM_COMPRESSED);
+PHPBN2(SWF_SOUND_MP3_COMPRESSED);
+PHPBN2(SWF_SOUND_NOT_COMPRESSED_LE);
+PHPBN2(SWF_SOUND_NELLY_COMPRESSED);
+PHPBN2(SWF_SOUND_5KHZ);
+PHPBN2(SWF_SOUND_11KHZ);
+PHPBN2(SWF_SOUND_22KHZ);
+PHPBN2(SWF_SOUND_44KHZ);
+PHPBN2(SWF_SOUND_8BITS);
+PHPBN2(SWF_SOUND_16BITS);
+PHPBN2(SWF_SOUND_MONO);
+PHPBN2(SWF_SOUND_STEREO);
+PHPBN2(OPENSSL_VERSION_NUMBER);
+PHPBN2(SNMP_OID_OUTPUT_FULL);
+PHPBN2(SNMP_OID_OUTPUT_NUMERIC);
+PHPBN2(MSG_EAGAIN);
+PHPBN2(MSG_ENOMSG);
+
+/* Added in PHP 5.3 */
+PHPBN2(CURLOPT_PROGRESSFUNCTION);
+PHPBN2(IMG_FILTER_PIXELATE);
+PHPBN2(JSON_ERROR_CTRL_CHAR);
+PHPBN2(JSON_ERROR_DEPTH);
+PHPBN2(JSON_ERROR_NONE);
+PHPBN2(JSON_ERROR_STATE_MISMATCH);
+PHPBN2(JSON_ERROR_SYNTAX);
+PHPBN2(JSON_FORCE_OBJECT);
+PHPBN2(JSON_HEX_TAG);
+PHPBN2(JSON_HEX_AMP);
+PHPBN2(JSON_HEX_APOS);
+PHPBN2(JSON_HEX_QUOT);
+PHPBN2(LDAP_OPT_NETWORK_TIMEOUT);
+PHPBN2(LIBXML_LOADED_VERSION);
+PHPBN2(PREG_BAD_UTF8_OFFSET_ERROR);
+PHPBN2(BUS_ADRALN);
+PHPBN2(BUS_ADRERR);
+PHPBN2(BUS_OBJERR);
+PHPBN2(CLD_CONTIUNED);
+PHPBN2(CLD_DUMPED);
+PHPBN2(CLD_EXITED);
+PHPBN2(CLD_KILLED);
+PHPBN2(CLD_STOPPED);
+PHPBN2(CLD_TRAPPED);
+PHPBN2(FPE_FLTDIV);
+PHPBN2(FPE_FLTINV);
+PHPBN2(FPE_FLTOVF);
+PHPBN2(FPE_FLTRES);
+PHPBN2(FPE_FLTSUB);
+PHPBN2(FPE_FLTUND);
+PHPBN2(FPE_INTDIV);
+PHPBN2(FPE_INTOVF);
+PHPBN2(ILL_BADSTK);
+PHPBN2(ILL_COPROC);
+PHPBN2(ILL_ILLADR);
+PHPBN2(ILL_ILLOPC);
+PHPBN2(ILL_ILLOPN);
+PHPBN2(ILL_ILLTRP);
+PHPBN2(ILL_PRVOPC);
+PHPBN2(ILL_PRVREG);
+PHPBN2(POLL_ERR);
+PHPBN2(POLL_HUP);
+PHPBN2(POLL_IN);
+PHPBN2(POLL_MSG);
+PHPBN2(POLL_OUT);
+PHPBN2(POLL_PRI);
+PHPBN2(SEGV_ACCERR);
+PHPBN2(SEGV_MAPERR);
+PHPBN2(SI_ASYNCIO);
+PHPBN2(SI_KERNEL);
+PHPBN2(SI_MESGQ);
+PHPBN2(SI_NOINFO);
+PHPBN2(SI_QUEUE);
+PHPBN2(SI_SIGIO);
+PHPBN2(SI_TIMER);
+PHPBN2(SI_TKILL);
+PHPBN2(SI_USER);
+PHPBN2(SIG_BLOCK);
+PHPBN2(SIG_SETMASK);
+PHPBN2(SIG_UNBLOCK);
+PHPBN2(TRAP_BRKPT);
+PHPBN2(TRAP_TRACE);
+
+/* Added in PHP 5.4 */
+PHPBN2(ENT_DISALLOWED);
+PHPBN2(ENT_HTML401);
+PHPBN2(ENT_HTML5);
+PHPBN2(ENT_SUBSTITUTE);
+PHPBN2(ENT_XML1);
+PHPBN2(ENT_XHTML);
+PHPBN2(IPPROTO_IP);
+PHPBN2(IPPROTO_IPV6);
+PHPBN2(IPV6_MULTICAST_HOPS);
+PHPBN2(IPV6_MULTICAST_IF);
+PHPBN2(IPV6_MULTICAST_LOOP);
+PHPBN2(IP_MULTICAST_IF);
+PHPBN2(IP_MULTICAST_LOOP);
+PHPBN2(IP_MULTICAST_TTL);
+PHPBN2(MCAST_JOIN_GROUP);
+PHPBN2(MCAST_LEAVE_GROUP);
+PHPBN2(MCAST_BLOCK_SOURCE);
+PHPBN2(MCAST_UNBLOCK_SOURCE);
+PHPBN2(MCAST_JOIN_SOURCE_GROUP);
+PHPBN2(MCAST_LEAVE_SOURCE_GROUP);
+PHPBN2(CURLOPT_MAX_RECV_SPEED_LARGE);
+PHPBN2(CURLOPT_MAX_SEND_SPEED_LARGE);
+PHPBN2(LIBXML_HTML_NODEFDTD);
+PHPBN2(LIBXML_HTML_NOIMPLIED);
+PHPBN2(LIBXML_PEDANTIC);
+PHPBN2(OPENSSL_CIPHER_AES_128_CBC);
+PHPBN2(OPENSSL_CIPHER_AES_192_CBC);
+PHPBN2(OPENSSL_CIPHER_AES_256_CBC);
+PHPBN2(OPENSSL_RAW_DATA);
+PHPBN2(OPENSSL_ZERO_PADDING);
+PHPBN2(PHP_OUTPUT_HANDLER_CLEAN);
+PHPBN2(PHP_OUTPUT_HANDLER_CLEANABLE);
+PHPBN2(PHP_OUTPUT_HANDLER_DISABLED);
+PHPBN2(PHP_OUTPUT_HANDLER_FINAL);
+PHPBN2(PHP_OUTPUT_HANDLER_FLUSH);
+PHPBN2(PHP_OUTPUT_HANDLER_FLUSHABLE);
+PHPBN2(PHP_OUTPUT_HANDLER_REMOVABLE);
+PHPBN2(PHP_OUTPUT_HANDLER_STARTED);
+PHPBN2(PHP_OUTPUT_HANDLER_STDFLAGS);
+PHPBN2(PHP_OUTPUT_HANDLER_WRITE);
+PHPBN2(PHP_SESSION_ACTIVE);
+PHPBN2(PHP_SESSION_DISABLED);
+PHPBN2(PHP_SESSION_NONE);
+PHPBN2(STREAM_META_ACCESS);
+PHPBN2(STREAM_META_GROUP);
+PHPBN2(STREAM_META_GROUP_NAME);
+PHPBN2(STREAM_META_OWNER);
+PHPBN2(STREAM_META_OWNER_NAME);
+PHPBN2(STREAM_META_TOUCH);
+PHPBN2(ZLIB_ENCODING_DEFLATE);
+PHPBN2(ZLIB_ENCODING_GZIP);
+PHPBN2(ZLIB_ENCODING_RAW);
+PHPBN2(U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR);
+PHPBN2(IDNA_CHECK_BIDI);
+PHPBN2(IDNA_CHECK_CONTEXTJ);
+PHPBN2(IDNA_NONTRANSITIONAL_TO_ASCII);
+PHPBN2(IDNA_NONTRANSITIONAL_TO_UNICODE);
+PHPBN2(INTL_IDNA_VARIANT_2003);
+PHPBN2(INTL_IDNA_VARIANT_UTS46);
+PHPBN2(IDNA_ERROR_EMPTY_LABEL);
+PHPBN2(IDNA_ERROR_LABEL_TOO_LONG);
+PHPBN2(IDNA_ERROR_DOMAIN_NAME_TOO_LONG);
+PHPBN2(IDNA_ERROR_LEADING_HYPHEN);
+PHPBN2(IDNA_ERROR_TRAILING_HYPHEN);
+PHPBN2(IDNA_ERROR_HYPHEN_3_4);
+PHPBN2(IDNA_ERROR_LEADING_COMBINING_MARK);
+PHPBN2(IDNA_ERROR_DISALLOWED);
+PHPBN2(IDNA_ERROR_PUNYCODE);
+PHPBN2(IDNA_ERROR_LABEL_HAS_DOT);
+PHPBN2(IDNA_ERROR_INVALID_ACE_LABEL);
+PHPBN2(IDNA_ERROR_BIDI);
+PHPBN2(IDNA_ERROR_CONTEXTJ);
+PHPBN2(JSON_PRETTY_PRINT);
+PHPBN2(JSON_UNESCAPED_SLASHES);
+PHPBN2(JSON_NUMERIC_CHECK);
+PHPBN2(JSON_UNESCAPED_UNICODE);
+PHPBN2(JSON_BIGINT_AS_STRING);
+
+/* Added in PHP 5.5 */
+PHPBN2(IMG_AFFINE_TRANSLATE);
+PHPBN2(IMG_AFFINE_SCALE);
+PHPBN2(IMG_AFFINE_ROTATE);
+PHPBN2(IMG_AFFINE_SHEAR_HORIZONTAL);
+PHPBN2(IMG_AFFINE_SHEAR_VERTICAL);
+PHPBN2(IMG_CROP_DEFAULT);
+PHPBN2(IMG_CROP_TRANSPARENT);
+PHPBN2(IMG_CROP_BLACK);
+PHPBN2(IMG_CROP_WHITE);
+PHPBN2(IMG_CROP_SIDES);
+PHPBN2(IMG_FLIP_BOTH);
+PHPBN2(IMG_FLIP_HORIZONTAL);
+PHPBN2(IMG_FLIP_VERTICAL);
+PHPBN2(IMG_BELL);
+PHPBN2(IMG_BESSEL);
+PHPBN2(IMG_BICUBIC);
+PHPBN2(IMG_BICUBIC_FIXED);
+PHPBN2(IMG_BLACKMAN);
+PHPBN2(IMG_BOX);
+PHPBN2(IMG_BSPLINE);
+PHPBN2(IMG_CATMULLROM);
+PHPBN2(IMG_GAUSSIAN);
+PHPBN2(IMG_GENERALIZED_CUBIC);
+PHPBN2(IMG_HERMITE);
+PHPBN2(IMG_HAMMING);
+PHPBN2(IMG_HANNING);
+PHPBN2(IMG_MITCHELL);
+PHPBN2(IMG_POWER);
+PHPBN2(IMG_QUADRATIC);
+PHPBN2(IMG_SINC);
+PHPBN2(IMG_NEAREST_NEIGHBOUR);
+PHPBN2(IMG_WEIGHTED4);
+PHPBN2(IMG_TRIANGLE);
+PHPBN2(JSON_ERROR_RECURSION);
+PHPBN2(JSON_ERROR_INF_OR_NAN);
+PHPBN2(JSON_ERROR_UNSUPPORTED_TYPE);
+PHPBN2(MYSQLI_SERVER_PUBLIC_KEY);
+
+/* Added in PHP 5.6 */
+PHPBN2(LDAP_ESCAPE_DN);
+PHPBN2(LDAP_ESCAPE_FILTER);
+PHPBN2(OPENSSL_DEFAULT_STREAM_CIPHERS);
+PHPBN2(STREAM_CRYPTO_METHOD_ANY_CLIENT);
+PHPBN2(STREAM_CRYPTO_METHOD_ANY_SERVER);
+PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT);
+PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_0_SERVER);
+PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT);
+PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_1_SERVER);
+PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT);
+PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_2_SERVER);
+PHPBN2(PGSQL_CONNECT_ASYNC);
+PHPBN2(PGSQL_CONNECTION_AUTH_OK);
+PHPBN2(PGSQL_CONNECTION_AWAITING_RESPONSE);
+PHPBN2(PGSQL_CONNECTION_MADE);
+PHPBN2(PGSQL_CONNECTION_SETENV);
+PHPBN2(PGSQL_CONNECTION_SSL_STARTUP);
+PHPBN2(PGSQL_CONNECTION_STARTED);
+PHPBN2(PGSQL_DML_ESCAPE);
+PHPBN2(PGSQL_POLLING_ACTIVE);
+PHPBN2(PGSQL_POLLING_FAILED);
+PHPBN2(PGSQL_POLLING_OK);
+PHPBN2(PGSQL_POLLING_READING);
+PHPBN2(PGSQL_POLLING_WRITING);
+
+/* Class names reserved by PHP (case insensitive) */
+PHPCN(directory);
+PHPCN(stdclass);
+PHPCN(__php_incomplete_class);
+/* Added in PHP5. */
+PHPCN(exception);
+PHPCN(errorexception); // As of PHP 5.1
+PHPCN(php_user_filter);
+PHPCN(closure); // As of PHP 5.3
+PHPCN(generator); // As of PHP 5.5
+PHPCN(self);
+PHPCN(static);
+PHPCN(parent);
+/* http://php.net/manual/en/migration70.incompatible.php#migration70.incompatible.other.classes */
+PHPCN(bool); // As of PHP 7.0
+PHPCN(int); // As of PHP 7.0
+PHPCN(float); // As of PHP 7.0
+PHPCN(string); // As of PHP 7.0
+PHPCN(NULL); // As of PHP 7.0
+PHPCN(TRUE); // As of PHP 7.0
+PHPCN(FALSE); // As of PHP 7.0
+PHPCN(resource); // As of PHP 7.0 (currently works but reserved)
+PHPCN(object); // As of PHP 7.0 (currently works but reserved)
+PHPCN(mixed); // As of PHP 7.0 (currently works but reserved)
+PHPCN(numeric); // As of PHP 7.0 (currently works but reserved)
+/* http://php.net/manual/en/migration71.incompatible.php#migration71.incompatible.invalid-class-names */
+PHPCN(iterable); // As of PHP 7.1
+PHPCN(void); // As of PHP 7.1
+/* From extensions (which of these are actually predefined depends which
+ * extensions are loaded by default). */
+PHPCN(xmlwriter);
+PHPCN(libxmlerror);
+PHPCN(simplexmlelement);
+PHPCN(soapclient);
+PHPCN(soapvar);
+PHPCN(soapserver);
+PHPCN(soapfault);
+PHPCN(soapparam);
+PHPCN(soapheader);
+PHPCN(recursiveiteratoriterator);
+PHPCN(filteriterator);
+PHPCN(recursivefilteriterator);
+PHPCN(parentiterator);
+PHPCN(limititerator);
+PHPCN(cachingiterator);
+PHPCN(recursivecachingiterator);
+PHPCN(iteratoriterator);
+PHPCN(norewinditerator);
+PHPCN(appenditerator);
+PHPCN(infiniteiterator);
+PHPCN(emptyiterator);
+PHPCN(arrayobject);
+PHPCN(arrayiterator);
+PHPCN(recursivearrayiterator);
+PHPCN(splfileinfo);
+PHPCN(directoryiterator);
+PHPCN(recursivedirectoryiterator);
+PHPCN(splfileobject);
+PHPCN(spltempfileobject);
+PHPCN(simplexmliterator);
+PHPCN(logicexception);
+PHPCN(badfunctioncallexception);
+PHPCN(badmethodcallexception);
+PHPCN(domainexception);
+PHPCN(invalidargumentexception);
+PHPCN(lengthexception);
+PHPCN(outofrangeexception);
+PHPCN(runtimeexception);
+PHPCN(outofboundsexception);
+PHPCN(overflowexception);
+PHPCN(rangeexception);
+PHPCN(underflowexception);
+PHPCN(unexpectedvalueexception);
+PHPCN(splobjectstorage);
+PHPCN(reflectionexception);
+PHPCN(reflection);
+PHPCN(reflectionfunction);
+PHPCN(reflectionparameter);
+PHPCN(reflectionmethod);
+PHPCN(reflectionclass);
+PHPCN(reflectionobject);
+PHPCN(reflectionproperty);
+PHPCN(reflectionextension);
+PHPCN(domexception);
+PHPCN(domstringlist);
+PHPCN(domnamelist);
+PHPCN(domimplementationlist);
+PHPCN(domimplementationsource);
+PHPCN(domimplementation);
+PHPCN(domnode);
+PHPCN(domnamespacenode);
+PHPCN(domdocumentfragment);
+PHPCN(domdocument);
+PHPCN(domnodelist);
+PHPCN(domnamednodemap);
+PHPCN(domcharacterdata);
+PHPCN(domattr);
+PHPCN(domelement);
+PHPCN(domtext);
+PHPCN(domcomment);
+PHPCN(domtypeinfo);
+PHPCN(domuserdatahandler);
+PHPCN(domdomerror);
+PHPCN(domerrorhandler);
+PHPCN(domlocator);
+PHPCN(domconfiguration);
+PHPCN(domcdatasection);
+PHPCN(domdocumenttype);
+PHPCN(domnotation);
+PHPCN(domentity);
+PHPCN(domentityreference);
+PHPCN(domprocessinginstruction);
+PHPCN(domstringextend);
+PHPCN(domxpath);
+PHPCN(xmlreader);
+PHPCN(sqlitedatabase);
+PHPCN(sqliteresult);
+PHPCN(sqliteunbuffered);
+PHPCN(sqliteexception);
+PHPCN(datetime);
+
+/* Built-in PHP functions (incomplete). */
+/* Includes Array Functions - http://php.net/manual/en/ref.array.php */
+/* Check is case insensitive - these *MUST* be listed in lower case here */
+PHPFN(acos);
+PHPFN(array_change_key_case);
+PHPFN(array_chunk);
+PHPFN(array_column);
+PHPFN(array_combine);
+PHPFN(array_count_values);
+PHPFN(array_diff);
+PHPFN(array_diff_assoc);
+PHPFN(array_diff_key);
+PHPFN(array_diff_uassoc);
+PHPFN(array_diff_ukey);
+PHPFN(array_fill);
+PHPFN(array_fill_keys);
+PHPFN(array_filter);
+PHPFN(array_flip);
+PHPFN(array_intersect);
+PHPFN(array_intersect_assoc);
+PHPFN(array_intersect_key);
+PHPFN(array_intersect_uassoc);
+PHPFN(array_intersect_ukey);
+PHPFN(array_key_exists);
+PHPFN(array_keys);
+PHPFN(array_map);
+PHPFN(array_merge);
+PHPFN(array_merge_recursive);
+PHPFN(array_multisort);
+PHPFN(array_pad);
+PHPFN(array_pop);
+PHPFN(array_product);
+PHPFN(array_push);
+PHPFN(array_rand);
+PHPFN(array_reduce);
+PHPFN(array_replace);
+PHPFN(array_replace_recursive);
+PHPFN(array_reverse);
+PHPFN(array_search);
+PHPFN(array_shift);
+PHPFN(array_slice);
+PHPFN(array_splice);
+PHPFN(array_sum);
+PHPFN(array_udiff);
+PHPFN(array_udiff_assoc);
+PHPFN(array_udiff_uassoc);
+PHPFN(array_uintersect);
+PHPFN(array_uintersect_assoc);
+PHPFN(array_uintersect_uassoc);
+PHPFN(array_unique);
+PHPFN(array_unshift);
+PHPFN(array_values);
+PHPFN(array_walk);
+PHPFN(array_walk_recursive);
+PHPFN(arsort);
+PHPFN(asin);
+PHPFN(asort);
+PHPFN(atan);
+PHPFN(atan2);
+PHPFN(ceil);
+PHPFN(compact);
+PHPFN(cos);
+PHPFN(cosh);
+PHPFN(count);
+PHPFN(current);
+PHPFN(each);
+PHPFN(end);
+PHPFN(exp);
+PHPFN(extract);
+PHPFN(floor);
+PHPFN(fmod);
+PHPFN(in_array);
+PHPFN(key);
+PHPFN(key_exists);
+PHPFN(krsort);
+PHPFN(ksort);
+PHPFN(log);
+PHPFN(log10);
+PHPFN(max);
+PHPFN(min);
+PHPFN(natcasesort);
+PHPFN(natsort);
+PHPFN(next);
+PHPFN(pos);
+PHPFN(pow);
+PHPFN(prev);
+PHPFN(range);
+PHPFN(reset);
+PHPFN(rsort);
+PHPFN(shuffle);
+PHPFN(sin);
+PHPFN(sinh);
+PHPFN(sizeof);
+PHPFN(sort);
+PHPFN(sqrt);
+PHPFN(tan);
+PHPFN(tanh);
+PHPFN(uasort);
+PHPFN(uksort);
+PHPFN(usort);
+
+#undef PHPKW
+#undef PHPBN1a
+#undef PHPBN1b
+#undef PHPBN1
+#undef PHPBN2a
+#undef PHPBN2b
+#undef PHPBN2
+#undef PHPCN
+#undef PHPFN
diff --git a/share/swig/3.0.12/php/phppointers.i b/share/swig/3.0.12/php/phppointers.i
new file mode 100644
index 0000000..d79697b
--- /dev/null
+++ b/share/swig/3.0.12/php/phppointers.i
@@ -0,0 +1,46 @@
+%define %pass_by_ref( TYPE, CONVERT_IN, CONVERT_OUT )
+%typemap(in, byref=1) TYPE *REF ($*1_ltype tmp),
+             TYPE &REF ($*1_ltype tmp)
+%{
+  /* First Check for SWIG wrapped type */
+  if (Z_ISNULL($input)) {
+      $1 = 0;
+  } else if (Z_ISREF($input)) {
+      /* Not swig wrapped type, so we check if it's a PHP reference type */
+      CONVERT_IN(tmp, $*1_ltype, $input);
+      $1 = &tmp;
+  } else {
+      SWIG_PHP_Error(E_ERROR, SWIG_PHP_Arg_Error_Msg($argnum, Expected a reference));
+  }
+%}
+%typemap(argout) TYPE *REF,
+                 TYPE &REF
+%{
+  if (Z_ISREF($input)) {
+    CONVERT_OUT(Z_REFVAL($input), tmp$argnum);
+  }
+%}
+%enddef
+
+%pass_by_ref( size_t, CONVERT_INT_IN, ZVAL_LONG );
+
+%pass_by_ref( signed int, CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( int, CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( unsigned int, CONVERT_INT_IN, ZVAL_LONG );
+
+%pass_by_ref( signed short, CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( short, CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( unsigned short, CONVERT_INT_IN, ZVAL_LONG );
+
+%pass_by_ref( signed long, CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( long, CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( unsigned long, CONVERT_INT_IN, ZVAL_LONG );
+
+%pass_by_ref( signed char, CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( char, CONVERT_CHAR_IN, ZVAL_STRING );
+%pass_by_ref( unsigned char, CONVERT_INT_IN, ZVAL_LONG );
+
+%pass_by_ref( float, CONVERT_FLOAT_IN, ZVAL_DOUBLE );
+%pass_by_ref( double, CONVERT_FLOAT_IN, ZVAL_DOUBLE );
+
+%pass_by_ref( char *, CONVERT_CHAR_IN, ZVAL_STRING );
diff --git a/share/swig/3.0.12/php/phprun.swg b/share/swig/3.0.12/php/phprun.swg
new file mode 100644
index 0000000..5c62d19
--- /dev/null
+++ b/share/swig/3.0.12/php/phprun.swg
@@ -0,0 +1,239 @@
+/* -----------------------------------------------------------------------------
+ * phprun.swg
+ *
+ * PHP runtime library
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "zend.h"
+#include "zend_API.h"
+#include "zend_exceptions.h"
+#include "php.h"
+
+#if PHP_MAJOR_VERSION != 7
+# error These bindings need PHP7 - to generate PHP5 bindings use: swig -php5
+#endif
+
+#include "ext/standard/php_string.h"
+#include <stdlib.h> /* for abort(), used in generated code. */
+
+/* This indirection is to work around const correctness issues in older PHP.
+ * FIXME: Remove for PHP7?  Or might user code be using it? */
+#define SWIG_ZEND_NAMED_FE(ZN, N, A) ZEND_NAMED_FE(ZN, N, A)
+
+#define SWIG_BOOL_CONSTANT(N, V) REGISTER_BOOL_CONSTANT(#N, V, CONST_CS | CONST_PERSISTENT)
+#define SWIG_LONG_CONSTANT(N, V) REGISTER_LONG_CONSTANT(#N, V, CONST_CS | CONST_PERSISTENT)
+#define SWIG_DOUBLE_CONSTANT(N, V) REGISTER_DOUBLE_CONSTANT(#N, V, CONST_CS | CONST_PERSISTENT)
+#define SWIG_STRING_CONSTANT(N, V) REGISTER_STRING_CONSTANT(#N, (char*)V, CONST_CS | CONST_PERSISTENT)
+#define SWIG_CHAR_CONSTANT(N, V) do {\
+    char swig_char = (V);\
+    REGISTER_STRINGL_CONSTANT(#N, &swig_char, 1, CONST_CS | CONST_PERSISTENT);\
+} while (0)
+
+#ifdef __cplusplus
+}
+#endif
+
+#define SWIG_fail goto fail
+
+static const char *default_error_msg = "Unknown error occurred";
+static int default_error_code = E_ERROR;
+
+#define SWIG_PHP_Arg_Error_Msg(argnum,extramsg) "Error in argument " #argnum " "#extramsg
+
+#define SWIG_PHP_Error(code,msg) do { SWIG_ErrorCode() = code; SWIG_ErrorMsg() = msg; SWIG_fail; } while (0)
+
+#define SWIG_contract_assert(expr,msg) \
+  if (!(expr) ) { zend_printf("Contract Assert Failed %s\n",msg ); } else
+
+/* Standard SWIG API */
+#define SWIG_GetModule(clientdata) SWIG_Php_GetModule()
+#define SWIG_SetModule(clientdata, pointer) SWIG_Php_SetModule(pointer)
+
+/* used to wrap returned objects in so we know whether they are newobject
+   and need freeing, or not */
+typedef struct {
+  void * ptr;
+  int newobject;
+} swig_object_wrapper;
+
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
+
+static void
+SWIG_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject) {
+  /*
+   * First test for Null pointers.  Return those as PHP native NULL
+   */
+  if (!ptr ) {
+    ZVAL_NULL(z);
+    return;
+  }
+  if (type->clientdata) {
+    swig_object_wrapper *value;
+    if (! (*(int *)(type->clientdata)))
+      zend_error(E_ERROR, "Type: %s failed to register with zend",type->name);
+    value=(swig_object_wrapper *)emalloc(sizeof(swig_object_wrapper));
+    value->ptr=ptr;
+    value->newobject=(newobject & 1);
+    if ((newobject & 2) == 0) {
+      /* Just register the pointer as a resource. */
+      ZVAL_RES(z, zend_register_resource(value, *(int *)(type->clientdata)));
+    } else {
+      /*
+       * Wrap the resource in an object, the resource will be accessible
+       * via the "_cPtr" member. This is currently only used by
+       * directorin typemaps.
+       */
+      zval resource;
+      zend_class_entry *ce = NULL;
+      const char *type_name = type->name+3; /* +3 so: _p_Foo -> Foo */
+      size_t type_name_len;
+      const char * p;
+      HashTable * ht;
+
+      /* Namespace__Foo -> Foo */
+      /* FIXME: ugly and goes wrong for classes with __ in their names. */
+      while ((p = strstr(type_name, "__")) != NULL) {
+        type_name = p + 2;
+      }
+      type_name_len = strlen(type_name);
+
+      ZVAL_RES(&resource, zend_register_resource(value, *(int *)(type->clientdata)));
+      if (SWIG_PREFIX_LEN > 0) {
+        zend_string * classname = zend_string_alloc(SWIG_PREFIX_LEN + type_name_len, 0);
+        memcpy(classname->val, SWIG_PREFIX, SWIG_PREFIX_LEN);
+        memcpy(classname->val + SWIG_PREFIX_LEN, type_name, type_name_len);
+        ce = zend_lookup_class(classname);
+        zend_string_release(classname);
+      } else {
+        zend_string * classname = zend_string_init(type_name, type_name_len, 0);
+        ce = zend_lookup_class(classname);
+        zend_string_release(classname);
+      }
+      if (ce == NULL) {
+        /* class does not exist */
+        ce = zend_standard_class_def;
+      }
+
+      ALLOC_HASHTABLE(ht);
+      zend_hash_init(ht, 1, NULL, NULL, 0);
+      zend_hash_str_update(ht, "_cPtr", sizeof("_cPtr") - 1, &resource);
+      object_and_properties_init(z, ce, ht);
+    }
+    return;
+  }
+  zend_error(E_ERROR, "Type: %s not registered with zend",type->name);
+}
+
+/* This pointer conversion routine takes the native pointer p (along with
+   its type name) and converts it by calling appropriate casting functions
+   according to ty.  The resultant pointer is returned, or NULL is returned
+   if the pointer can't be cast.
+
+   Sadly PHP has no API to find a type name from a type id, only from an
+   instance of a resource of the type id, so we have to pass type_name as well.
+
+   The two functions which might call this are:
+   SWIG_ConvertResourcePtr which gets the type name from the resource
+   and the registered zend destructors for which we have one per type each
+   with the type name hard wired in. */
+static void *
+SWIG_ConvertResourceData(void * p, const char *type_name, swig_type_info *ty) {
+  swig_cast_info *tc;
+  void *result = 0;
+
+  if (!ty) {
+    /* They don't care about the target type, so just pass on the pointer! */
+    return p;
+  }
+
+  if (! type_name) {  
+    /* can't convert p to ptr type ty if we don't know what type p is */
+    return NULL;
+  }
+
+  /* convert and cast p from type_name to ptr as ty. */
+  tc = SWIG_TypeCheck(type_name, ty);
+  if (tc) {
+    int newmemory = 0;
+    result = SWIG_TypeCast(tc, p, &newmemory);
+    assert(!newmemory); /* newmemory handling not yet implemented */
+  }
+  return result;
+}
+
+/* This function returns a pointer of type ty by extracting the pointer
+   and type info from the resource in z.  z must be a resource.
+   If it fails, NULL is returned.
+   It uses SWIG_ConvertResourceData to do the real work. */
+static void *
+SWIG_ConvertResourcePtr(zval *z, swig_type_info *ty, int flags) {
+  swig_object_wrapper *value;
+  void *p;
+  const char *type_name;
+
+  if (Z_RES_TYPE_P(z) == -1) return NULL;
+  value = (swig_object_wrapper *) Z_RES_VAL_P(z);
+  if (flags & SWIG_POINTER_DISOWN) {
+    value->newobject = 0;
+  }
+  p = value->ptr;
+
+  type_name=zend_rsrc_list_get_rsrc_type(Z_RES_P(z));
+
+  return SWIG_ConvertResourceData(p, type_name, ty);
+}
+
+/* We allow passing of a RESOURCE pointing to the object or an OBJECT whose
+   _cPtr is a resource pointing to the object */
+static int
+SWIG_ConvertPtr(zval *z, void **ptr, swig_type_info *ty, int flags) {
+  if (z == NULL) {
+    *ptr = 0;
+    return 0;
+  }
+
+  switch (Z_TYPE_P(z)) {
+    case IS_OBJECT: {
+      HashTable * ht = Z_OBJ_HT_P(z)->get_properties(z);
+      if (ht) {
+        zval * _cPtr = zend_hash_str_find(ht, "_cPtr", sizeof("_cPtr") - 1);
+        if (_cPtr) {
+          if (Z_TYPE_P(_cPtr) == IS_INDIRECT) {
+            _cPtr = Z_INDIRECT_P(_cPtr);
+          }
+          if (Z_TYPE_P(_cPtr) == IS_RESOURCE) {
+            *ptr = SWIG_ConvertResourcePtr(_cPtr, ty, flags);
+            return (*ptr == NULL ? -1 : 0);
+          }
+        }
+      }
+      break;
+    }
+    case IS_RESOURCE:
+      *ptr = SWIG_ConvertResourcePtr(z, ty, flags);
+      return (*ptr == NULL ? -1 : 0);
+    case IS_NULL:
+      *ptr = 0;
+      return 0;
+  }
+
+  return -1;
+}
+
+static char const_name[] = "swig_runtime_data_type_pointer";
+static swig_module_info *SWIG_Php_GetModule() {
+  zval *pointer = zend_get_constant_str(const_name, sizeof(const_name) - 1);
+  if (pointer) {
+    if (Z_TYPE_P(pointer) == IS_LONG) {
+      return (swig_module_info *) pointer->value.lval;
+    }
+  } 
+  return NULL;
+}
+
+static void SWIG_Php_SetModule(swig_module_info *pointer) {
+  REGISTER_MAIN_LONG_CONSTANT(const_name, (long) pointer, CONST_PERSISTENT | CONST_CS);
+}
diff --git a/share/swig/2.0.11/php/std_common.i b/share/swig/3.0.12/php/std_common.i
index 092bf01..092bf01 100644
--- a/share/swig/2.0.11/php/std_common.i
+++ b/share/swig/3.0.12/php/std_common.i
diff --git a/share/swig/3.0.12/php/std_deque.i b/share/swig/3.0.12/php/std_deque.i
new file mode 100644
index 0000000..cb98f6c
--- /dev/null
+++ b/share/swig/3.0.12/php/std_deque.i
@@ -0,0 +1 @@
+%include <std/_std_deque.i>
diff --git a/share/swig/2.0.11/php/std_map.i b/share/swig/3.0.12/php/std_map.i
index 6d5e3db..6d5e3db 100644
--- a/share/swig/2.0.11/php/std_map.i
+++ b/share/swig/3.0.12/php/std_map.i
diff --git a/share/swig/3.0.12/php/std_pair.i b/share/swig/3.0.12/php/std_pair.i
new file mode 100644
index 0000000..fe45ee6
--- /dev/null
+++ b/share/swig/3.0.12/php/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/3.0.12/php/std_string.i b/share/swig/3.0.12/php/std_string.i
new file mode 100644
index 0000000..b55751f
--- /dev/null
+++ b/share/swig/3.0.12/php/std_string.i
@@ -0,0 +1,94 @@
+/* -----------------------------------------------------------------------------
+ * std_string.i
+ *
+ * SWIG typemaps for std::string types
+ * ----------------------------------------------------------------------------- */
+
+// ------------------------------------------------------------------------
+// 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>
+
+%{
+#include <string>
+%}
+
+namespace std {
+
+    %naturalvar string;
+
+    class string;
+
+    %typemap(typecheck,precedence=SWIG_TYPECHECK_STRING) string, const string& %{
+        $1 = (Z_TYPE($input) == IS_STRING) ? 1 : 0;
+    %}
+
+    %typemap(in) string %{
+        convert_to_string(&$input);
+        $1.assign(Z_STRVAL($input), Z_STRLEN($input));
+    %}
+
+    %typemap(directorout) string %{
+      if (!EG(exception)) {
+        convert_to_string($input);
+        $result.assign(Z_STRVAL_P($input), Z_STRLEN_P($input));
+      }
+    %}
+
+    %typemap(out) string %{
+        ZVAL_STRINGL($result, $1.data(), $1.size());
+    %}
+
+    %typemap(directorin) string, const string& %{
+        ZVAL_STRINGL($input, $1.data(), $1.size());
+    %}
+
+    %typemap(out) const string & %{
+        ZVAL_STRINGL($result, $1->data(), $1->size());
+    %}
+
+    %typemap(throws) string, const string& %{
+        zend_throw_exception(NULL, $1.c_str(), 0);
+        return;
+    %}
+
+    %typemap(in) const string & ($*1_ltype temp) %{
+        convert_to_string(&$input);
+        temp.assign(Z_STRVAL($input), Z_STRLEN($input));
+        $1 = &temp;
+    %}
+
+    /* These next two handle a function which takes a non-const reference to
+     * a std::string and modifies the string. */
+    %typemap(in,byref=1) string & ($*1_ltype temp) %{
+        {
+          zval * p = Z_ISREF($input) ? Z_REFVAL($input) : &$input;
+          convert_to_string(p);
+          temp.assign(Z_STRVAL_P(p), Z_STRLEN_P(p));
+          $1 = &temp;
+        }
+    %}
+
+    %typemap(directorout) string & ($*1_ltype *temp) %{
+      if (!EG(exception)) {
+        convert_to_string($input);
+        temp = new $*1_ltype(Z_STRVAL_P($input), Z_STRLEN_P($input));
+        swig_acquire_ownership(temp);
+        $result = temp;
+      }
+    %}
+
+    %typemap(argout) string & %{
+      if (Z_ISREF($input)) {
+        ZVAL_STRINGL(Z_REFVAL($input), $1->data(), $1->size());
+      }
+    %}
+
+    /* SWIG will apply the non-const typemap above to const string& without
+     * this more specific typemap. */
+    %typemap(argout) const string & "";
+}
diff --git a/share/swig/3.0.12/php/std_vector.i b/share/swig/3.0.12/php/std_vector.i
new file mode 100644
index 0000000..9cc1486
--- /dev/null
+++ b/share/swig/3.0.12/php/std_vector.i
@@ -0,0 +1,102 @@
+/* -----------------------------------------------------------------------------
+ * std_vector.i
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.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);
+    void clear();
+    %rename(push) push_back;
+    void push_back(const value_type& x);
+    %extend {
+      bool is_empty() const {
+        return $self->empty();
+      }
+      T pop() throw (std::out_of_range) {
+        if (self->size() == 0)
+          throw std::out_of_range("pop from empty vector");
+        T x = self->back();
+        self->pop_back();
+        return x;
+      }
+      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);
+    void clear();
+    %rename(push) push_back;
+    void push_back(const value_type& x);
+    %extend {
+      bool is_empty() const {
+        return $self->empty();
+      }
+      bool pop() throw (std::out_of_range) {
+        if (self->size() == 0)
+          throw std::out_of_range("pop from empty vector");
+        bool x = self->back();
+        self->pop_back();
+        return x;
+      }
+      bool 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");
+      }
+    }
+  };
+}
+
+%define specialize_std_vector(T)
+#warning "specialize_std_vector - specialization for type T no longer needed"
+%enddef
+
+
diff --git a/share/swig/2.0.11/php/stl.i b/share/swig/3.0.12/php/stl.i
index 9d2e91e..9d2e91e 100644
--- a/share/swig/2.0.11/php/stl.i
+++ b/share/swig/3.0.12/php/stl.i
diff --git a/share/swig/3.0.12/php/typemaps.i b/share/swig/3.0.12/php/typemaps.i
new file mode 100644
index 0000000..c248a58
--- /dev/null
+++ b/share/swig/3.0.12/php/typemaps.i
@@ -0,0 +1,305 @@
+/* -----------------------------------------------------------------------------
+ * typemaps.i.
+ *
+ * SWIG Typemap library for PHP.
+ *
+ * This library provides standard typemaps for modifying SWIG's behavior.
+ * With enough entries in this file, I hope that very few people actually
+ * ever need to write a typemap.
+ *
+ * Define macros to define the following typemaps:
+ *
+ * TYPE *INPUT.   Argument is passed in as native variable by value.
+ * TYPE *OUTPUT.  Argument is returned as an array from the function call.
+ * TYPE *INOUT.   Argument is passed in by value, and out as part of returned list
+ * TYPE *REFERENCE.  Argument is passed in as native variable with value
+ *                   semantics.  Variable value is changed with result.
+ *                   Use like this:
+ *                   int foo(int *REFERENCE);
+ *
+ *                   $a = 0;
+ *                   $rc = foo($a);
+ *
+ *                   Even though $a looks like it's passed by value,
+ *                   its value can be changed by foo().
+ * ----------------------------------------------------------------------------- */
+
+%define BOOL_TYPEMAP(TYPE)
+%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
+%{
+  convert_to_boolean(&$input);
+  temp = (Z_TYPE($input) == IS_TRUE);
+  $1 = &temp;
+%}
+%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
+%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
+%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
+{
+  zval o;
+  ZVAL_BOOL(&o, temp$argnum);
+  t_output_helper($result, &o);
+}
+%typemap(in) TYPE *REFERENCE (TYPE lvalue), TYPE &REFERENCE (TYPE lvalue)
+%{
+  convert_to_boolean($input);
+  lvalue = (Z_TYPE_P($input) == IS_TRUE);
+  $1 = &lvalue;
+%}
+%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
+%{
+  ZVAL_BOOL(&$arg, lvalue$argnum ? true : false);
+%}
+%enddef
+
+%define DOUBLE_TYPEMAP(TYPE)
+%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
+%{
+  temp = (TYPE) zval_get_double(&$input);
+  $1 = &temp;
+%}
+%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
+%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
+%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
+{
+  zval o;
+  ZVAL_DOUBLE(&o, temp$argnum);
+  t_output_helper($result, &o);
+}
+%typemap(in) TYPE *REFERENCE (TYPE dvalue), TYPE &REFERENCE (TYPE dvalue)
+%{
+  dvalue = (TYPE) zval_get_double(&$input);
+  $1 = &dvalue;
+%}
+%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
+%{
+  ZVAL_DOUBLE(&$arg, (double)(lvalue$argnum));
+%}
+%enddef
+
+%define INT_TYPEMAP(TYPE)
+%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
+%{
+  temp = (TYPE) zval_get_long(&$input);
+  $1 = &temp;
+%}
+%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
+%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
+%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
+{
+  zval o;
+  ZVAL_LONG(&o, temp$argnum);
+  t_output_helper($result, &o);
+}
+%typemap(in) TYPE *REFERENCE (TYPE lvalue), TYPE &REFERENCE (TYPE lvalue)
+%{
+  lvalue = (TYPE) zval_get_long(&$input);
+  $1 = &lvalue;
+%}
+%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
+%{
+  ZVAL_LONG(&$arg, (long)(lvalue$argnum));
+%}
+%enddef
+
+BOOL_TYPEMAP(bool);
+
+DOUBLE_TYPEMAP(float);
+DOUBLE_TYPEMAP(double);
+
+INT_TYPEMAP(int);
+INT_TYPEMAP(short);
+INT_TYPEMAP(long);
+INT_TYPEMAP(unsigned int);
+INT_TYPEMAP(unsigned short);
+INT_TYPEMAP(unsigned long);
+INT_TYPEMAP(unsigned char);
+INT_TYPEMAP(signed char);
+
+INT_TYPEMAP(long long);
+%typemap(argout,fragment="t_output_helper") long long *OUTPUT
+{
+  zval o;
+  if ((long long)LONG_MIN <= temp$argnum && temp$argnum <= (long long)LONG_MAX) {
+    ZVAL_LONG(&o, (long)temp$argnum);
+  } else {
+    char temp[256];
+    sprintf(temp, "%lld", (long long)temp$argnum);
+    ZVAL_STRING(&o, temp);
+  }
+  t_output_helper($result, &o);
+}
+%typemap(in) TYPE *REFERENCE (long long lvalue)
+%{
+  CONVERT_LONG_LONG_IN(lvalue, long long, $input)
+  $1 = &lvalue;
+%}
+%typemap(argout) long long *REFERENCE
+%{
+  if ((long long)LONG_MIN <= lvalue$argnum && lvalue$argnum <= (long long)LONG_MAX) {
+    ZVAL_LONG(&$arg, (long)temp$argnum);
+  } else {
+    char temp[256];
+    sprintf(temp, "%lld", (long long)lvalue$argnum);
+    ZVAL_STRING(&$arg, temp);
+  }
+%}
+%typemap(argout) long long &OUTPUT
+%{
+  if ((long long)LONG_MIN <= *arg$argnum && *arg$argnum <= (long long)LONG_MAX) {
+    ZVAL_LONG($result, (long)(*arg$argnum));
+  } else {
+    char temp[256];
+    sprintf(temp, "%lld", (long long)(*arg$argnum));
+    ZVAL_STRING($result, temp);
+  }
+%}
+INT_TYPEMAP(unsigned long long);
+%typemap(argout,fragment="t_output_helper") unsigned long long *OUTPUT
+{
+  zval o;
+  if (temp$argnum <= (unsigned long long)LONG_MAX) {
+    ZVAL_LONG(&o, temp$argnum);
+  } else {
+    char temp[256];
+    sprintf(temp, "%llu", (unsigned long long)temp$argnum);
+    ZVAL_STRING(&o, temp);
+  }
+  t_output_helper($result, &o);
+}
+%typemap(in) TYPE *REFERENCE (unsigned long long lvalue)
+%{
+  CONVERT_UNSIGNED_LONG_LONG_IN(lvalue, unsigned long long, $input)
+  $1 = &lvalue;
+%}
+%typemap(argout) unsigned long long *REFERENCE
+%{
+  if (lvalue$argnum <= (unsigned long long)LONG_MAX) {
+    ZVAL_LONG($arg, (long)(lvalue$argnum));
+  } else {
+    char temp[256];
+    sprintf(temp, "%llu", (unsigned long long)lvalue$argnum);
+    ZVAL_STRING((*$arg), temp);
+  }
+%}
+%typemap(argout) unsigned long long &OUTPUT
+%{
+  if (*arg$argnum <= (unsigned long long)LONG_MAX) {
+    ZVAL_LONG($result, (long)(*arg$argnum));
+  } else {
+    char temp[256];
+    sprintf(temp, "%llu", (unsigned long long)(*arg$argnum));
+    ZVAL_STRING($result, temp);
+  }
+%}
+
+%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) 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 char *INOUT = unsigned char *INPUT;
+%typemap(in) unsigned long long *INOUT = unsigned long long *INPUT;
+%typemap(in) signed char *INOUT = signed 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) short &INOUT = short *INPUT;
+%typemap(in) long &INOUT = long *INPUT;
+%typemap(in) long long &INOUT = long long *INPUT;
+%typemap(in) long long &INPUT = 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 char &INOUT = unsigned char *INPUT;
+%typemap(in) unsigned long long &INOUT = unsigned long long *INPUT;
+%typemap(in) unsigned long long &INPUT = unsigned long long *INPUT;
+%typemap(in) signed char &INOUT = signed char *INPUT;
+
+%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) short *INOUT = short *OUTPUT;
+%typemap(argout) long *INOUT= long *OUTPUT;
+%typemap(argout) long long *INOUT= long long *OUTPUT;
+%typemap(argout) unsigned short *INOUT= unsigned short *OUTPUT;
+%typemap(argout) unsigned long *INOUT = unsigned long *OUTPUT;
+%typemap(argout) unsigned char *INOUT = unsigned char *OUTPUT;
+%typemap(argout) unsigned long long *INOUT = unsigned long long *OUTPUT;
+%typemap(argout) signed char *INOUT = signed 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) short &INOUT = short *OUTPUT;
+%typemap(argout) long &INOUT= long *OUTPUT;
+%typemap(argout) long long &INOUT= long long *OUTPUT;
+%typemap(argout) unsigned short &INOUT= unsigned short *OUTPUT;
+%typemap(argout) unsigned long &INOUT = unsigned long *OUTPUT;
+%typemap(argout) unsigned char &INOUT = unsigned char *OUTPUT;
+%typemap(argout) unsigned long long &INOUT = unsigned long long *OUTPUT;
+%typemap(argout) signed char &INOUT = signed char *OUTPUT;
+
+%typemap(in) char INPUT[ANY] ( char temp[$1_dim0] )
+%{
+  convert_to_string(&$input);
+  strncpy(temp, Z_STRVAL($input), $1_dim0);
+  $1 = temp;
+%}
+%typemap(in,numinputs=0) char OUTPUT[ANY] ( char temp[$1_dim0] )
+  "$1 = temp;";
+%typemap(argout,fragment="t_output_helper") char OUTPUT[ANY]
+{
+  zval o;
+  ZVAL_STRINGL(&o, temp$argnum, $1_dim0);
+  t_output_helper($result, &o);
+}
+
+%typemap(in,numinputs=0) void **OUTPUT (int force),
+                         void *&OUTPUT (int force)
+%{
+  /* If they pass NULL by reference, make it into a void*
+     This bit should go in arginit if arginit support init-ing scripting args */
+  if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, 0) < 0) {
+    /* So... we didn't get a ref or ptr, but we'll accept NULL by reference */
+    if (!(Z_ISREF($input) && Z_ISNULL_P(Z_REFVAL($input)))) {
+      /* wasn't a pre/ref/thing, OR anything like an int thing */
+      SWIG_PHP_Error(E_ERROR, "Type error in argument $arg of $symname.");
+    }
+  }
+  force=0;
+  if (arg1==NULL) {
+#ifdef __cplusplus
+    ptr=new $*1_ltype();
+#else
+    ptr=($*1_ltype) calloc(1,sizeof($*1_ltype));
+#endif
+    $1=&ptr;
+    /* have to passback arg$arg too */
+    force=1;
+  }
+%}
+
+%typemap(argout) void **OUTPUT,
+                 void *&OUTPUT
+%{
+  if (force$argnum) {  /* pass back arg$argnum through params ($arg) if we can */
+    if (!Z_ISREF($arg)) {
+      SWIG_PHP_Error(E_WARNING, "Parameter $argnum of $symname wasn't passed by reference");
+    } else {
+      SWIG_SetPointerZval(*$arg, (void *) ptr$argnum, $*1_descriptor, 1);
+    }
+  }
+%}
diff --git a/share/swig/3.0.12/php/utils.i b/share/swig/3.0.12/php/utils.i
new file mode 100644
index 0000000..8581646
--- /dev/null
+++ b/share/swig/3.0.12/php/utils.i
@@ -0,0 +1,116 @@
+
+%define CONVERT_BOOL_IN(lvar,t,invar)
+  lvar = (t) zval_is_true(&invar);
+%enddef
+
+%define CONVERT_INT_IN(lvar,t,invar)
+  lvar = (t) zval_get_long(&invar);
+%enddef
+
+%define CONVERT_LONG_LONG_IN(lvar,t,invar)
+  switch (Z_TYPE(invar)) {
+      case IS_DOUBLE:
+          lvar = (t) Z_DVAL(invar);
+          break;
+      case IS_STRING: {
+          char * endptr;
+          errno = 0;
+          lvar = (t) strtoll(Z_STRVAL(invar), &endptr, 10);
+          if (*endptr && !errno) break;
+          /* FALL THRU */
+      }
+      default:
+          lvar = (t) zval_get_long(&invar);
+  }
+%enddef
+
+%define CONVERT_UNSIGNED_LONG_LONG_IN(lvar,t,invar)
+  switch (Z_TYPE(invar)) {
+      case IS_DOUBLE:
+          lvar = (t) Z_DVAL(invar);
+          break;
+      case IS_STRING: {
+          char * endptr;
+          errno = 0;
+          lvar = (t) strtoull(Z_STRVAL(invar), &endptr, 10);
+          if (*endptr && !errno) break;
+          /* FALL THRU */
+      }
+      default:
+          lvar = (t) zval_get_long(&invar);
+  }
+%enddef
+
+%define CONVERT_INT_OUT(lvar,invar)
+  lvar = (t) zval_get_long(&invar);
+%enddef
+
+%define CONVERT_FLOAT_IN(lvar,t,invar)
+  lvar = (t) zval_get_double(&invar);
+%enddef
+
+%define CONVERT_CHAR_IN(lvar,t,invar)
+  convert_to_string(&invar);
+  lvar = (t) Z_STRVAL(invar)[0];
+%enddef
+
+%define CONVERT_STRING_IN(lvar,t,invar)
+  if (Z_ISNULL(invar)) {
+    lvar = (t) 0;
+  } else {
+    convert_to_string(&invar);
+    lvar = (t) Z_STRVAL(invar);
+  }
+%enddef
+
+%define %pass_by_val( TYPE, CONVERT_IN )
+%typemap(in) TYPE
+%{
+  CONVERT_IN($1,$1_ltype,$input);
+%}
+%typemap(in) const TYPE & ($*1_ltype temp)
+%{
+  CONVERT_IN(temp,$*1_ltype,$input);
+  $1 = &temp;
+%}
+%typemap(directorout) TYPE
+%{
+  if (!EG(exception)) {
+    CONVERT_IN($result, $1_ltype, *$input);
+  } else {
+    typedef $1_ltype swig_result_typedef;
+    $result = swig_result_typedef();
+  }
+%}
+%typemap(directorout) const TYPE & ($*1_ltype temp)
+%{
+  if (!EG(exception)) {
+    CONVERT_IN(temp, $*1_ltype, *$input);
+  } else {
+    typedef $*1_ltype swig_result_typedef;
+    temp = swig_result_typedef();
+  }
+  $result = &temp;
+%}
+%enddef
+
+%fragment("t_output_helper","header") %{
+static void
+t_output_helper(zval *target, zval *o) {
+  zval tmp;
+  if (Z_TYPE_P(target) == IS_ARRAY) {
+    /* it's already an array, just append */
+    add_next_index_zval(target, o);
+    return;
+  }
+  if (Z_TYPE_P(target) == IS_NULL) {
+    /* NULL isn't refcounted */
+    ZVAL_COPY_VALUE(target, o);
+    return;
+  }
+  ZVAL_DUP(&tmp, target);
+  array_init(target);
+  add_next_index_zval(target, &tmp);
+  add_next_index_zval(target, o);
+}
+%}
diff --git a/share/swig/3.0.12/php5/const.i b/share/swig/3.0.12/php5/const.i
new file mode 100644
index 0000000..061ba99
--- /dev/null
+++ b/share/swig/3.0.12/php5/const.i
@@ -0,0 +1,51 @@
+/* -----------------------------------------------------------------------------
+ * const.i
+ *
+ * Typemaps for constants
+ * ----------------------------------------------------------------------------- */
+
+%typemap(consttab) int,
+                   unsigned int,
+                   short,
+                   unsigned short,
+                   long,
+                   unsigned long,
+                   unsigned char,
+                   signed char,
+                   bool,
+                   enum SWIGTYPE
+  "SWIG_LONG_CONSTANT($symname, ($1_type)$value);";
+
+%typemap(consttab) float,
+                   double
+  "SWIG_DOUBLE_CONSTANT($symname, $value);";
+
+%typemap(consttab) char
+  "SWIG_CHAR_CONSTANT($symname, $value);";
+
+%typemap(consttab) char *,
+                   const char *,
+                   char [],
+                   const char []
+  "SWIG_STRING_CONSTANT($symname, $value);";
+
+%typemap(consttab) SWIGTYPE *,
+                   SWIGTYPE &,
+                   SWIGTYPE &&,
+                   SWIGTYPE [] {
+  zval *z_var;
+  zend_constant c;
+  size_t len = sizeof("$symname") - 1;
+  MAKE_STD_ZVAL(z_var);
+  SWIG_SetPointerZval(z_var, (void*)$value, $1_descriptor, 0);
+  c.value = *z_var;
+  zval_copy_ctor(&c.value);
+  c.name = zend_strndup("$symname", len);
+  c.name_len = len+1;
+  c.flags = CONST_CS | CONST_PERSISTENT;
+  c.module_number = module_number;
+  zend_register_constant( &c TSRMLS_CC );
+}
+
+/* Handled as a global variable. */
+%typemap(consttab) SWIGTYPE (CLASS::*) "";
diff --git a/share/swig/3.0.12/php5/director.swg b/share/swig/3.0.12/php5/director.swg
new file mode 100644
index 0000000..638a169
--- /dev/null
+++ b/share/swig/3.0.12/php5/director.swg
@@ -0,0 +1,170 @@
+/* -----------------------------------------------------------------------------
+ * director.swg
+ *
+ * This file contains support for director classes so that PHP proxy
+ * methods can be called from C++.
+ * ----------------------------------------------------------------------------- */
+
+#ifndef SWIG_DIRECTOR_PHP_HEADER_
+#define SWIG_DIRECTOR_PHP_HEADER_
+
+#include <string>
+#include <exception>
+#include <map>
+
+namespace Swig {
+
+  /* memory handler */
+  struct GCItem {
+    virtual ~GCItem() {
+    }
+
+    virtual int get_own() const {
+      return 0;
+    }
+  };
+
+  struct GCItem_var {
+    GCItem_var(GCItem *item = 0) : _item(item) {
+    }
+
+    GCItem_var& operator=(GCItem *item) {
+      GCItem *tmp = _item;
+      _item = item;
+      delete tmp;
+      return *this;
+    }
+
+    ~GCItem_var() {
+      delete _item;
+    }
+
+    GCItem * operator->() const {
+      return _item;
+    }
+
+    private:
+    GCItem *_item;
+  };
+
+  struct GCItem_Object : GCItem {
+    GCItem_Object(int own) : _own(own) {
+    }
+
+    virtual ~GCItem_Object() {
+    }
+
+    int get_own() const {
+      return _own;
+    }
+
+    private:
+    int _own;
+  };
+
+  template <typename Type>
+  struct GCItem_T : GCItem {
+    GCItem_T(Type *ptr) : _ptr(ptr) {
+    }
+
+    virtual ~GCItem_T() {
+      delete _ptr;
+    }
+
+    private:
+    Type *_ptr;
+  };
+
+  class Director {
+    protected:
+      zval *swig_self;
+      typedef std::map<void *, GCItem_var> swig_ownership_map;
+      mutable swig_ownership_map swig_owner;
+#ifdef ZTS
+      // Store the ZTS context so it's available when C++ calls back to PHP.
+      void *** swig_zts_ctx;
+#endif
+    public:
+      Director(zval *self TSRMLS_DC) : swig_self(self) {
+        TSRMLS_SET_CTX(swig_zts_ctx);
+      }
+
+      static bool swig_is_overridden_method(char *cname, char *lc_fname TSRMLS_DC) {
+        zend_class_entry **ce;
+        zend_function *mptr;
+
+        if (zend_lookup_class(cname, strlen(cname), &ce TSRMLS_CC) != SUCCESS) {
+          return false;
+        }
+        if (zend_hash_find(&(*ce)->function_table, lc_fname, strlen(lc_fname) + 1, (void **) &mptr) != SUCCESS) {
+          return false;
+        }
+        // common.scope points to the declaring class
+        return strcmp(mptr->common.scope->name, cname);
+      }
+
+      template <typename Type>
+      void swig_acquire_ownership(Type *vptr) const {
+        if (vptr) {
+          swig_owner[vptr] = new GCItem_T<Type>(vptr);
+        }
+      }
+  };
+
+  /* base class for director exceptions */
+  class DirectorException : public std::exception {
+  protected:
+    std::string swig_msg;
+  public:
+    DirectorException(int code, const char *hdr, const char *msg TSRMLS_DC) : swig_msg(hdr) {
+      if (msg[0]) {
+        swig_msg += " ";
+        swig_msg += msg;
+      }
+      SWIG_ErrorCode() = code;
+      SWIG_ErrorMsg() = swig_msg.c_str();
+    }
+
+    virtual ~DirectorException() throw() {
+    }
+
+    const char *what() const throw() {
+      return swig_msg.c_str();
+    }
+
+    static void raise(int code, const char *hdr, const char *msg TSRMLS_DC) {
+      throw DirectorException(code, hdr, msg TSRMLS_CC);
+    }
+  };
+
+  /* attempt to call a pure virtual method via a director method */
+  class DirectorPureVirtualException : public DirectorException {
+  public:
+    DirectorPureVirtualException(const char *msg TSRMLS_DC)
+      : DirectorException(E_ERROR, "SWIG director pure virtual method called", msg TSRMLS_CC) {
+    }
+
+    static void raise(const char *msg TSRMLS_DC) {
+      throw DirectorPureVirtualException(msg TSRMLS_CC);
+    }
+  };
+
+  /* any php exception that occurs during a director method call */
+  class DirectorMethodException : public DirectorException
+  {
+  public:
+    DirectorMethodException(const char *msg TSRMLS_DC)
+      : DirectorException(E_ERROR, "SWIG director method error", msg TSRMLS_CC) {
+    }
+
+    static void raise(const char *msg TSRMLS_DC) {
+      throw DirectorMethodException(msg TSRMLS_CC);
+    }
+  };
+}
+
+// DirectorMethodException() is documented to be callable with no parameters
+// so use a macro to insert TSRMLS_CC so any ZTS context gets passed.
+#define DirectorMethodException() DirectorMethodException("" TSRMLS_CC)
+
+#endif
diff --git a/share/swig/3.0.12/php5/factory.i b/share/swig/3.0.12/php5/factory.i
new file mode 100644
index 0000000..c4e082d
--- /dev/null
+++ b/share/swig/3.0.12/php5/factory.i
@@ -0,0 +1,109 @@
+/*
+  Implement a more natural wrap for factory methods, for example, if
+  you have:
+
+  ----  geometry.h --------
+       struct Geometry {                          
+         enum GeomType{			     
+           POINT,				     
+           CIRCLE				     
+         };					     
+         					     
+         virtual ~Geometry() {}    		     
+         virtual int draw() = 0;
+	 
+	 //
+	 // Factory method for all the Geometry objects
+	 //
+         static Geometry *create(GeomType i);     
+       };					     
+       					     
+       struct Point : Geometry  {		     
+         int draw() { return 1; }		     
+         double width() { return 1.0; }    	     
+       };					     
+       					     
+       struct Circle : Geometry  {		     
+         int draw() { return 2; }		     
+         double radius() { return 1.5; }          
+       }; 					     
+       
+       //
+       // Factory method for all the Geometry objects
+       //
+       Geometry *Geometry::create(GeomType type) {
+         switch (type) {			     
+         case POINT: return new Point();	     
+         case CIRCLE: return new Circle(); 	     
+         default: return 0;			     
+         }					     
+       }					    
+  ----  geometry.h --------
+
+
+  You can use the %factory with the Geometry::create method as follows:
+
+    %newobject Geometry::create;
+    %factory(Geometry *Geometry::create, Point, Circle);
+    %include "geometry.h"
+
+  and Geometry::create will return a 'Point' or 'Circle' instance
+  instead of the plain 'Geometry' type. For example, in python:
+
+    circle = Geometry.create(Geometry.CIRCLE)
+    r = circle.radius()
+
+  where circle is a Circle proxy instance.
+
+  NOTES: remember to fully qualify all the type names and don't
+  use %factory inside a namespace declaration, ie, instead of
+  
+     namespace Foo {
+       %factory(Geometry *Geometry::create, Point, Circle);
+     }
+
+  use
+
+     %factory(Foo::Geometry *Foo::Geometry::create, Foo::Point,  Foo::Circle);   
+
+     
+*/
+
+/* for loop for macro with one argument */
+%define %_formacro_1(macro, arg1,...)macro(arg1)
+#if #__VA_ARGS__ != "__fordone__"
+%_formacro_1(macro, __VA_ARGS__)
+#endif
+%enddef
+
+/* for loop for macro with one argument */
+%define %formacro_1(macro,...)%_formacro_1(macro,__VA_ARGS__,__fordone__)%enddef
+%define %formacro(macro,...)%_formacro_1(macro,__VA_ARGS__,__fordone__)%enddef
+
+/* for loop for macro with two arguments */
+%define %_formacro_2(macro, arg1, arg2, ...)macro(arg1, arg2)
+#if #__VA_ARGS__ != "__fordone__"
+%_formacro_2(macro, __VA_ARGS__)
+#endif
+%enddef
+
+/* for loop for macro with two arguments */
+%define %formacro_2(macro,...)%_formacro_2(macro, __VA_ARGS__, __fordone__)%enddef
+
+%define %_factory_dispatch(Type) 
+if (!dcast) {
+  Type *dobj = dynamic_cast<Type *>($1);
+  if (dobj) {
+    dcast = 1;
+    SWIG_SetPointerZval(return_value, SWIG_as_voidptr(dobj),$descriptor(Type *), $owner);
+  }   
+}%enddef
+
+%define %factory(Method,Types...)
+%typemap(out) Method {
+  int dcast = 0;
+  %formacro(%_factory_dispatch, Types)
+  if (!dcast) {
+    SWIG_SetPointerZval(return_value, SWIG_as_voidptr($1),$descriptor, $owner);
+  }
+}%enddef
diff --git a/share/swig/3.0.12/php5/globalvar.i b/share/swig/3.0.12/php5/globalvar.i
new file mode 100644
index 0000000..a3e99f5
--- /dev/null
+++ b/share/swig/3.0.12/php5/globalvar.i
@@ -0,0 +1,361 @@
+/* -----------------------------------------------------------------------------
+ * globalvar.i
+ *
+ * Global variables - add the variable to PHP
+ * ----------------------------------------------------------------------------- */
+
+%typemap(varinit) char *
+{
+  zval *z_var;
+  MAKE_STD_ZVAL(z_var);
+  z_var->type = IS_STRING;
+  if($1) {
+      z_var->value.str.val = estrdup($1);
+      z_var->value.str.len = strlen($1);
+  } else {
+      z_var->value.str.val = 0;
+      z_var->value.str.len = 0;
+  }
+  zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var, sizeof(zval *), NULL);
+}
+
+%typemap(varinit) char []
+{
+  zval *z_var;
+  MAKE_STD_ZVAL(z_var);
+  z_var->type = IS_STRING;
+  z_var->value.str.val = estrdup($1);
+  z_var->value.str.len = strlen($1);
+  zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var, sizeof(zval *), NULL);
+}
+
+%typemap(varinit) int,
+	          unsigned int,
+                  unsigned short,
+                  short,
+                  unsigned short,
+                  long,
+                  unsigned long,
+                  signed char,
+                  unsigned char,
+                  enum SWIGTYPE
+{
+  zval *z_var;
+  MAKE_STD_ZVAL(z_var);
+  z_var->type = IS_LONG;
+  z_var->value.lval = (long)$1;
+  zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var, sizeof(zval *), NULL);
+}
+
+%typemap(varinit) bool
+{
+  zval *z_var;
+  MAKE_STD_ZVAL(z_var);
+  z_var->type = IS_BOOL;
+  z_var->value.lval = ($1)?1:0;
+  zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var, sizeof(zval *), NULL);
+}
+
+%typemap(varinit) float, double
+{
+  zval *z_var;
+  MAKE_STD_ZVAL(z_var);
+  z_var->type = IS_DOUBLE;
+  z_var->value.dval = $1;
+  zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var,
+  sizeof(zval *), NULL);
+}
+
+%typemap(varinit) char
+{
+  zval *z_var;
+  char c[2];
+  MAKE_STD_ZVAL(z_var);
+  c[0] = $1;
+  c[1] = 0;
+  z_var->type = IS_STRING;
+  z_var->value.str.val = estrndup(c, 1);
+  z_var->value.str.len = 1;
+  zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var,
+  sizeof(zval *), NULL);
+}
+
+%typemap(varinit) SWIGTYPE *, SWIGTYPE []
+{
+  zval *z_var;
+  MAKE_STD_ZVAL(z_var);
+  SWIG_SetPointerZval(z_var, (void*)$1, $1_descriptor, 0);
+  zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var,
+  sizeof(zval *), NULL);
+}
+
+%typemap(varinit) SWIGTYPE, SWIGTYPE &, SWIGTYPE &&
+{
+  zval *z_var;
+
+  MAKE_STD_ZVAL(z_var);
+  SWIG_SetPointerZval(z_var, (void*)&$1, $&1_descriptor, 0);
+  zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void*)&z_var,
+  sizeof(zval *), NULL);
+}
+
+%typemap(varinit) char [ANY]
+{
+  zval *z_var;
+  MAKE_STD_ZVAL(z_var);
+  z_var->type = IS_STRING;
+  ZVAL_STRINGL(z_var,(char*)$1, $1_dim0, 1);
+  zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void*)&z_var, sizeof(zval *), NULL);
+}
+
+%typemap(varinit, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
+{
+  void * p = emalloc(sizeof($1));
+  memcpy(p, &$1, sizeof($1));
+  zval * resource;
+  MAKE_STD_ZVAL(resource);
+  ZEND_REGISTER_RESOURCE(resource, p, swig_member_ptr);
+  zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void*)&resource, sizeof(zval *), NULL);
+}
+
+%typemap(varin) int, unsigned int, short, unsigned short, long, unsigned long, signed char, unsigned char,  enum SWIGTYPE
+{
+  zval **z_var;
+
+  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
+  convert_to_long_ex(z_var);
+  if ($1 != ($1_ltype)((*z_var)->value.lval)) {
+    $1 = Z_LVAL_PP(z_var);
+  }
+}
+
+%typemap(varin) bool
+{
+  zval **z_var;
+
+  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
+  convert_to_boolean_ex(z_var);
+  if ($1 != ($1_ltype)((*z_var)->value.lval)) {
+    $1 = Z_LVAL_PP(z_var);
+  }
+}
+
+%typemap(varin) double,float
+{
+  zval **z_var;
+
+  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
+  convert_to_double_ex(z_var);
+  if ($1 != ($1_ltype)((*z_var)->value.dval)) {
+    $1 = Z_DVAL_PP(z_var);
+  }
+}
+
+%typemap(varin) char
+{
+  zval **z_var;
+
+  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
+  convert_to_string_ex(z_var);
+  if ($1 != *((*z_var)->value.str.val)) {
+    $1 = *((*z_var)->value.str.val);
+  }
+}
+
+%typemap(varin) char *
+{
+  zval **z_var;
+  char *s1;
+
+  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
+  convert_to_string_ex(z_var);
+  s1 = Z_STRVAL_PP(z_var);
+  if ((s1 == NULL) || ($1 == NULL) || strcmp(s1, $1)) {
+    if (s1)
+      $1 = estrdup(s1);
+    else
+      $1 = NULL;
+  }
+}
+
+
+%typemap(varin) SWIGTYPE []
+{
+  zval **z_var;
+
+  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
+  if($1) {
+    SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, $owner);
+  }
+}
+
+%typemap(varin) char [ANY]
+{
+ zval **z_var;
+ char *s1;
+
+ zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
+ s1 = Z_STRVAL_PP(z_var);
+ if ((s1 == NULL) || ($1 == NULL) || strcmp(s1, $1)) {
+   if (s1)
+     strncpy($1, s1, $1_dim0);
+ }
+}
+
+%typemap(varin) SWIGTYPE
+{
+  zval **z_var;
+  $&1_ltype _temp;
+
+  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
+  if (SWIG_ConvertPtr(*z_var, (void**)&_temp, $&1_descriptor, 0) < 0) {
+    SWIG_PHP_Error(E_ERROR,"Type error in value of $symname. Expected $&1_descriptor");
+  }
+
+  $1 = *($&1_ltype)_temp;
+
+}
+
+%typemap(varin) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&
+{
+  zval **z_var;
+  $1_ltype _temp;
+
+  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
+  if (SWIG_ConvertPtr(*z_var, (void **)&_temp, $1_descriptor, 0) < 0) {
+    SWIG_PHP_Error(E_ERROR,"Type error in value of $symname. Expected $&1_descriptor");
+  }
+
+  $1 = ($1_ltype)_temp;
+}
+
+%typemap(varin, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
+{
+  zval **z_var;
+
+  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
+  void * p = (void*)zend_fetch_resource(*z_var TSRMLS_CC, -1, SWIG_MEMBER_PTR, NULL, 1, swig_member_ptr);
+  memcpy(&$1, p, sizeof($1));
+}
+
+%typemap(varout) int,
+                 unsigned int,
+                 unsigned short,
+                 short,
+                 long,
+                 unsigned long,
+                 signed char,
+                 unsigned char,
+                 enum SWIGTYPE
+{
+  zval **z_var;
+  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
+  if($1 != ($1_ltype)((*z_var)->value.lval)) {
+    (*z_var)->value.lval = (long)$1;
+  }
+}
+
+//SAMFIX need to cast zval->type, what if zend-hash_find fails? etc?
+%typemap(varout) bool
+{
+  zval **z_var;
+  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
+  if($1 != ($1_ltype)((*z_var)->value.lval)) {
+    (*z_var)->value.lval = (long)$1;
+  }
+}
+
+%typemap(varout) double, float
+{
+  zval **z_var;
+  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
+  if($1 != ($1_ltype)((*z_var)->value.dval)) {
+    (*z_var)->value.dval = (double)$1;
+  }
+}
+
+%typemap(varout) char
+{
+  zval **z_var;
+  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
+  if($1 != *((*z_var)->value.str.val)) {
+    char c[2];
+    efree((*z_var)->value.str.val);
+    c[0] = $1;
+    c[1] = 0;
+    (*z_var)->value.str.val = estrdup(c);
+  }
+}
+
+%typemap(varout) char *
+{
+  zval **z_var;
+  char *s1;
+
+  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
+  s1 = Z_STRVAL_PP(z_var);
+  if((s1 == NULL) || ($1 == NULL) || strcmp(s1, $1)) {
+    if(s1)
+      efree(s1);
+    if($1) {
+      (*z_var)->value.str.val = estrdup($1);
+      (*z_var)->value.str.len = strlen($1) + 1;
+    } else {
+      (*z_var)->value.str.val = 0;
+      (*z_var)->value.str.len = 0;
+    }
+ }
+}
+
+%typemap(varout) SWIGTYPE
+{
+  zval **z_var;
+
+  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
+  SWIG_SetPointerZval(*z_var, (void*)&$1, $&1_descriptor, 0);
+}
+
+%typemap(varout) SWIGTYPE []
+{
+  zval **z_var;
+
+  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
+  if($1)
+    SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, 0);
+}
+
+%typemap(varout) char [ANY]
+{
+  zval **z_var;
+  char *s1;
+deliberate error cos this code looks bogus to me
+  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
+  s1 = Z_STRVAL_PP(z_var);
+  if((s1 == NULL) || strcmp(s1, $1)) {
+    if($1) {
+      (*z_var)->value.str.val = estrdup($1);
+      (*z_var)->value.str.len = strlen($1) + 1;
+    } else {
+      (*z_var)->value.str.val = 0;
+      (*z_var)->value.str.len = 0;
+    }
+  }
+}
+
+%typemap(varout) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&
+{
+  zval **z_var;
+
+  zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
+  SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, 0);
+}
+
+%typemap(varout, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
+{
+  void * p = emalloc(sizeof($1));
+  memcpy(p, &$1, sizeof($1));
+  zval * resource;
+  MAKE_STD_ZVAL(resource);
+  ZEND_REGISTER_RESOURCE(resource, p, swig_member_ptr);
+  zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void*)&resource, sizeof(zval *), NULL);
+}
diff --git a/share/swig/3.0.12/php5/php.swg b/share/swig/3.0.12/php5/php.swg
new file mode 100644
index 0000000..535c7d3
--- /dev/null
+++ b/share/swig/3.0.12/php5/php.swg
@@ -0,0 +1,529 @@
+/* -----------------------------------------------------------------------------
+ * php.swg
+ *
+ * PHP configuration file
+ * ----------------------------------------------------------------------------- */
+
+%runtime "swigrun.swg"  // Common C API type-checking code
+%runtime "phprun.swg"	// PHP runtime functions
+
+%include <phpinit.swg> // PHP initialization routine.
+
+%include <globalvar.i>	// Global variables.
+%include <const.i>
+
+// use %init %{ "/*code goes here*/ " %}
+// or  %minit %{ "/* code goes here*/ " %} to
+// insert code in the PHP_MINIT_FUNCTION
+#define %minit %insert("init")
+
+// use %rinit %{ "/* code goes here*/ " %} to
+// insert code in the PHP_RINIT_FUNCTION
+#define %rinit %insert("rinit")
+
+// use %shutdown %{ " /*code goes here*/ " %} to
+// insert code in the PHP_MSHUTDOWN_FUNCTION
+#define %shutdown  %insert("shutdown")
+#define %mshutdown  %insert("shutdown")
+
+// use %rshutdown %{ " /*code goes here*/" %} to
+// insert code in the PHP_RSHUTDOWN_FUNCTION
+#define %rshutdown  %insert("rshutdown")
+
+/* Typemaps for input parameters by value */
+
+%include <utils.i>
+
+%pass_by_val(bool,CONVERT_BOOL_IN);
+
+%pass_by_val(size_t, CONVERT_INT_IN);
+
+%pass_by_val(enum SWIGTYPE, CONVERT_INT_IN);
+
+%pass_by_val(signed int, CONVERT_INT_IN);
+%pass_by_val(int,CONVERT_INT_IN);
+%pass_by_val(unsigned int,CONVERT_INT_IN);
+
+%pass_by_val(signed short, CONVERT_INT_IN);
+%pass_by_val(short,CONVERT_INT_IN);
+%pass_by_val(unsigned short, CONVERT_INT_IN);
+
+%pass_by_val(signed long, CONVERT_INT_IN);
+%pass_by_val(long, CONVERT_INT_IN);
+%pass_by_val(unsigned long, CONVERT_INT_IN);
+
+%pass_by_val(signed long long, CONVERT_LONG_LONG_IN);
+%pass_by_val(long long, CONVERT_LONG_LONG_IN);
+%pass_by_val(unsigned long long, CONVERT_UNSIGNED_LONG_LONG_IN);
+
+%pass_by_val(signed char, CONVERT_INT_IN);
+%pass_by_val(char, CONVERT_CHAR_IN);
+%pass_by_val(unsigned char, CONVERT_INT_IN);
+
+%pass_by_val(float, CONVERT_FLOAT_IN);
+
+%pass_by_val(double, CONVERT_FLOAT_IN);
+
+%pass_by_val(char *, CONVERT_STRING_IN);
+%typemap(in) char *& = const char *&;
+%typemap(directorout) char *& = const char *&;
+
+// char array can be in/out, though the passed string may not be big enough...
+// so we have to size it
+%typemap(in) char[ANY]
+{
+   convert_to_string_ex($input);
+   $1 = ($1_ltype) Z_STRVAL_PP($input);
+}
+
+%typemap(in) (char *STRING, int LENGTH), (char *STRING, size_t LENGTH) {
+   convert_to_string_ex($input);
+   $1 = ($1_ltype) Z_STRVAL_PP($input);
+   $2 = ($2_ltype) Z_STRLEN_PP($input);
+}
+
+/* Object passed by value. Convert to a pointer */
+%typemap(in) SWIGTYPE ($&1_ltype tmp)
+{
+	if(SWIG_ConvertPtr(*$input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL) {
+          SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
+	}
+	$1 = *tmp;
+}
+
+%typemap(directorout) SWIGTYPE ($&1_ltype tmp)
+{
+	/* If exit was via exception, PHP NULL is returned so skip the conversion. */
+	if (!EG(exception)) {
+	  if(SWIG_ConvertPtr($input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL)
+	    SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
+	  $result = *tmp;
+	}
+}
+
+%typemap(in) SWIGTYPE *,
+	     SWIGTYPE []
+{
+	if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0) {
+            SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor");
+	}
+}
+
+%typemap(in) SWIGTYPE &
+{
+	if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0 || $1 == NULL) {
+	    SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor");
+	}
+}
+
+%typemap(in) SWIGTYPE &&
+{
+	if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0 || $1 == NULL) {
+	    SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor");
+	}
+}
+
+%typemap(in) SWIGTYPE *const& ($*ltype temp)
+{
+	if(SWIG_ConvertPtr(*$input, (void **) &temp, $*1_descriptor, 0) < 0) {
+            SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $*1_descriptor");
+	}
+	$1 = ($1_ltype)&temp;
+}
+
+%typemap(in) SWIGTYPE *DISOWN
+{
+  if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, SWIG_POINTER_DISOWN ) < 0) {
+    SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
+  }
+}
+
+%typemap(argout) SWIGTYPE *,
+                 SWIGTYPE [],
+                 SWIGTYPE &,
+                 SWIGTYPE &&;
+
+%typemap(in) void *
+{
+	if(SWIG_ConvertPtr(*$input, (void **) &$1, 0, 0) < 0) {
+	  /* Allow NULL from php for void* */
+	  if ((*$input)->type==IS_NULL) $1=0;
+	  else
+            SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
+	}
+}
+
+/* Special case when void* is passed by reference so it can be made to point
+   to opaque api structs */
+%typemap(in) void ** ($*1_ltype ptr, int force),
+             void *& ($*1_ltype ptr, int force)
+{
+  /* If they pass NULL by reference, make it into a void*
+     This bit should go in arginit if arginit support init-ing scripting args */
+  if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0) {
+    /* So... we didn't get a ref or ptr, but we'll accept NULL by reference */
+    if (!((*$input)->type==IS_NULL && PZVAL_IS_REF(*$input))) {
+      /* wasn't a pre/ref/thing, OR anything like an int thing */
+      SWIG_PHP_Error(E_ERROR, "Type error in argument $arg of $symname.");
+    }
+  }
+  force=0;
+  if (arg1==NULL) {
+#ifdef __cplusplus
+    ptr=new $*1_ltype();
+#else
+    ptr=($*1_ltype) calloc(1,sizeof($*1_ltype));
+#endif
+    $1=&ptr;
+    /* have to passback arg$arg too */
+    force=1;
+  }
+}
+%typemap(argout) void **,
+                 void *&
+{
+  if (force$argnum) {
+    SWIG_SetPointerZval( *$input, (void*) ptr$argnum, $*1_descriptor, 1);
+  }
+}
+
+/* Typemap for output values */
+
+%typemap(out) int,
+              unsigned int,
+              short,
+              unsigned short,
+              long,
+              unsigned long,
+              signed char,
+              unsigned char,
+              bool,
+              size_t
+{
+	ZVAL_LONG(return_value,$1);
+}
+
+%typemap(out) enum SWIGTYPE
+{
+	ZVAL_LONG(return_value, (long)$1);
+}
+
+%typemap(out) long long
+%{
+  if ((long long)LONG_MIN <= $1 && $1 <= (long long)LONG_MAX) {
+    return_value->value.lval = (long)($1);
+    return_value->type = IS_LONG;
+  } else {
+    char temp[256];
+    sprintf(temp, "%lld", (long long)$1);
+    ZVAL_STRING(return_value, temp, 1);
+  }
+%}
+%typemap(out) unsigned long long
+%{
+  if ($1 <= (unsigned long long)LONG_MAX) {
+    return_value->value.lval = (long)($1);
+    return_value->type = IS_LONG;
+  } else {
+    char temp[256];
+    sprintf(temp, "%llu", (unsigned long long)$1);
+    ZVAL_STRING(return_value, temp, 1);
+  }
+%}
+
+%typemap(out) const int &,
+              const unsigned int &,
+              const short &,
+              const unsigned short &,
+              const long &,
+              const unsigned long &,
+              const signed char &,
+              const unsigned char &,
+              const bool &,
+              const size_t &
+{
+	ZVAL_LONG(return_value,*$1);
+}
+
+%typemap(out) const enum SWIGTYPE &
+{
+	ZVAL_LONG(return_value, (long)*$1);
+}
+
+%typemap(out) const enum SWIGTYPE &&
+{
+	ZVAL_LONG(return_value, (long)*$1);
+}
+
+%typemap(out) const long long &
+%{
+  if ((long long)LONG_MIN <= *$1 && *$1 <= (long long)LONG_MAX) {
+    return_value->value.lval = (long)(*$1);
+    return_value->type = IS_LONG;
+  } else {
+    char temp[256];
+    sprintf(temp, "%lld", (long long)(*$1));
+    ZVAL_STRING(return_value, temp, 1);
+  }
+%}
+%typemap(out) const unsigned long long &
+%{
+  if (*$1 <= (unsigned long long)LONG_MAX) {
+    return_value->value.lval = (long)(*$1);
+    return_value->type = IS_LONG;
+  } else {
+    char temp[256];
+    sprintf(temp, "%llu", (unsigned long long)(*$1));
+    ZVAL_STRING(return_value, temp, 1);
+  }
+%}
+
+%typemap(directorin) int,
+              unsigned int,
+              short,
+              unsigned short,
+              long,
+              unsigned long,
+              signed char,
+              unsigned char,
+              size_t,
+              enum SWIGTYPE
+{
+  ZVAL_LONG($input,$1);
+}
+
+%typemap(directorin) enum SWIGTYPE
+{
+  ZVAL_LONG($input, (long)$1_name);
+}
+
+%typemap(directorin) char *, char []
+{
+    if(!$1) {
+      ZVAL_NULL($input);
+    } else {
+      ZVAL_STRING($input, (char *)$1, 1);
+    }
+}
+
+%typemap(out) bool
+{
+	ZVAL_BOOL(return_value,($1)?1:0);
+}
+
+%typemap(out) const bool &
+{
+	ZVAL_BOOL(return_value,(*$1)?1:0);
+}
+
+%typemap(directorin) bool
+{
+	ZVAL_BOOL($input,($1)?1:0);
+}
+
+%typemap(out) float,
+              double
+{
+	ZVAL_DOUBLE(return_value,$1);
+}
+
+%typemap(out) const float &,
+              const double &
+{
+	ZVAL_DOUBLE(return_value,*$1);
+}
+
+%typemap(directorin) float,
+                     double
+{
+	ZVAL_DOUBLE($input,$1);
+}
+
+%typemap(out) char
+{
+	ZVAL_STRINGL(return_value,&$1, 1, 1);
+}
+
+%typemap(out) const char &
+{
+	ZVAL_STRINGL(return_value,&*$1, 1, 1);
+}
+
+%typemap(out) char *,
+              char []
+{
+	if(!$1) {
+	  ZVAL_NULL(return_value);
+	} else {
+	  ZVAL_STRING(return_value, (char *)$1, 1);
+	}
+}
+
+%typemap(out) char *&
+{
+	if(!*$1) {
+	  ZVAL_NULL(return_value);
+	} else {
+	  ZVAL_STRING(return_value, (char *)*$1, 1);
+	}
+}
+
+%typemap(out) SWIGTYPE *,
+              SWIGTYPE [],
+              SWIGTYPE &,
+              SWIGTYPE &&
+%{
+  SWIG_SetPointerZval(return_value, (void *)$1, $1_descriptor, $owner);
+%}
+
+%typemap(out) SWIGTYPE *const&
+%{
+  SWIG_SetPointerZval(return_value, (void *)*$1, $*1_descriptor, $owner);
+%}
+
+%typemap(directorin) SWIGTYPE *,
+                     SWIGTYPE [],
+                     SWIGTYPE &,
+                     SWIGTYPE &&
+%{
+  SWIG_SetPointerZval($input, (void *)&$1, $1_descriptor, ($owner)|2);
+%}
+
+%typemap(out, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
+{
+  void * p = emalloc(sizeof($1));
+  memcpy(p, &$1, sizeof($1));
+  ZEND_REGISTER_RESOURCE(return_value, p, swig_member_ptr);
+}
+
+%typemap(in, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
+{
+  void * p = (void*)zend_fetch_resource($input TSRMLS_CC, -1, SWIG_MEMBER_PTR, NULL, 1, swig_member_ptr);
+  memcpy(&$1, p, sizeof($1));
+}
+
+%typemap(out) SWIGTYPE *DYNAMIC,
+              SWIGTYPE &DYNAMIC
+{
+  swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor, (void **) &$1);
+  SWIG_SetPointerZval(return_value, (void *)$1, ty, $owner);
+}
+
+%typemap(out) SWIGTYPE
+#ifdef __cplusplus
+{
+  $&1_ltype resultobj = new $1_ltype((const $1_ltype &) $1);
+  SWIG_SetPointerZval(return_value, (void *)resultobj, $&1_descriptor, 1);
+}
+#else
+{
+  $&1_ltype resultobj = ($&1_ltype) emalloc(sizeof($1_type));
+  memcpy(resultobj, &$1, sizeof($1_type));
+  SWIG_SetPointerZval(return_value, (void *)resultobj, $&1_descriptor, 1);
+}
+#endif
+
+%typemap(directorin) SWIGTYPE
+{
+  SWIG_SetPointerZval($input, SWIG_as_voidptr(new $1_ltype((const $1_ltype &)$1)), $&1_descriptor, 1|2);
+}
+
+%typemap(out) void "";
+
+%typemap(out) char [ANY]
+{
+  int len = 0;
+  while (len < $1_dim0 && $1[len]) ++len;
+  RETVAL_STRINGL($1, len, 1);
+}
+
+// This typecheck does hard checking for proper argument type.  If you want
+// an argument to be converted from a different PHP type, you must convert
+// it yourself before passing it (e.g. (string)4.7 or (int)"6").
+%define %php_typecheck(_type,_prec,is)
+%typemap(typecheck,precedence=_prec) _type, const _type &
+ " $1 = (Z_TYPE_PP($input) == is); "
+%enddef
+
+%php_typecheck(int,SWIG_TYPECHECK_INTEGER,IS_LONG)
+%php_typecheck(unsigned int,SWIG_TYPECHECK_UINT32,IS_LONG)
+%php_typecheck(short,SWIG_TYPECHECK_INT16,IS_LONG)
+%php_typecheck(unsigned short,SWIG_TYPECHECK_UINT16,IS_LONG)
+%php_typecheck(long,SWIG_TYPECHECK_INT32,IS_LONG)
+%php_typecheck(unsigned long,SWIG_TYPECHECK_UINT32,IS_LONG)
+%php_typecheck(long long,SWIG_TYPECHECK_INT64,IS_LONG)
+%php_typecheck(unsigned long long,SWIG_TYPECHECK_UINT64,IS_LONG)
+%php_typecheck(signed char,SWIG_TYPECHECK_INT8,IS_LONG)
+%php_typecheck(unsigned char,SWIG_TYPECHECK_UINT8,IS_LONG)
+%php_typecheck(size_t,SWIG_TYPECHECK_SIZE,IS_LONG)
+%php_typecheck(enum SWIGTYPE,SWIG_TYPECHECK_INTEGER,IS_LONG)
+%php_typecheck(bool,SWIG_TYPECHECK_BOOL,IS_BOOL)
+%php_typecheck(float,SWIG_TYPECHECK_FLOAT,IS_DOUBLE)
+%php_typecheck(double,SWIG_TYPECHECK_DOUBLE,IS_DOUBLE)
+%php_typecheck(char,SWIG_TYPECHECK_CHAR,IS_STRING)
+
+%typemap(typecheck,precedence=SWIG_TYPECHECK_STRING) char *, char *&, char []
+ " $1 = (Z_TYPE_PP($input) == IS_STRING); "
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE
+{
+  void *tmp;
+  _v = (SWIG_ConvertPtr(*$input, (void **)&tmp, $&1_descriptor, 0) >= 0);
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER)
+             SWIGTYPE *,
+             SWIGTYPE [],
+             SWIGTYPE &,
+             SWIGTYPE &&,
+             SWIGTYPE *const&
+{
+  void *tmp;
+  _v = (SWIG_ConvertPtr(*$input, (void**)&tmp, $1_descriptor, 0) >= 0);
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *const&
+{
+  void *tmp;
+  _v = (SWIG_ConvertPtr(*$input, (void**)&tmp, $*1_descriptor, 0) >= 0);
+}
+
+%typecheck(SWIG_TYPECHECK_VOIDPTR) void *
+{
+  void *tmp;
+  _v = (SWIG_ConvertPtr(*$input, (void**)&tmp, 0, 0) >= 0);
+}
+
+/* Exception handling */
+
+%typemap(throws) int,
+                 long,
+                 short,
+                 unsigned int,
+                 unsigned long,
+                 unsigned short {
+  zend_throw_exception(NULL, const_cast<char*>("C++ $1_type exception thrown"), $1 TSRMLS_CC);
+  return;
+}
+
+%typemap(throws) SWIGTYPE, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE *, SWIGTYPE [], SWIGTYPE [ANY] %{
+  (void)$1;
+  zend_throw_exception(NULL, const_cast<char*>("C++ $1_type exception thrown"), 0 TSRMLS_CC);
+  return;
+%}
+
+%typemap(throws) char * %{
+  zend_throw_exception(NULL, const_cast<char*>($1), 0 TSRMLS_CC);
+  return;
+%}
+
+/* Array reference typemaps */
+%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) }
+
+/* const pointers */
+%apply SWIGTYPE * { SWIGTYPE *const }
+
+
+/* php keywords */
+%include <phpkw.swg>
diff --git a/share/swig/3.0.12/php5/phpinit.swg b/share/swig/3.0.12/php5/phpinit.swg
new file mode 100644
index 0000000..d8a61b0
--- /dev/null
+++ b/share/swig/3.0.12/php5/phpinit.swg
@@ -0,0 +1,25 @@
+
+/* ------------------------------------------------------------
+ * The start of the PHP initialization function 
+ * ------------------------------------------------------------ */
+
+%insert(init) "swiginit.swg"
+
+%init %{
+SWIG_php_minit {
+    SWIG_InitializeModule(0);
+%}
+
+%fragment("swig_php_init_member_ptr2", "header") {
+#define SWIG_MEMBER_PTR ((char*)"CLASS::*")
+
+static void swig_member_ptr_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) {
+  efree(rsrc->ptr);
+}
+
+static int swig_member_ptr = 0;
+}
+
+%fragment("swig_php_init_member_ptr", "init", fragment="swig_php_init_member_ptr2") {
+    swig_member_ptr = zend_register_list_destructors_ex(swig_member_ptr_dtor, NULL, SWIG_MEMBER_PTR, module_number);
+}
diff --git a/share/swig/3.0.12/php5/phpkw.swg b/share/swig/3.0.12/php5/phpkw.swg
new file mode 100644
index 0000000..36e535f
--- /dev/null
+++ b/share/swig/3.0.12/php5/phpkw.swg
@@ -0,0 +1,866 @@
+/* -----------------------------------------------------------------------------
+ * phpkw.swg
+ * ----------------------------------------------------------------------------- */
+
+/* Keyword (case insensitive) */
+#define PHPKW(x) %keywordwarn("'" `x` "' is a PHP keyword, renaming to 'c_" `x` "'",sourcefmt="%(lower)s",rename="c_%s") `x`
+
+/* Class (case insensitive) */
+#define PHPCN(x) %keywordwarn("'" `x` "' is a PHP reserved class name, renaming to 'c_" `x` "'",%$isclass,sourcefmt="%(lower)s",rename="c_%s") `x`
+
+/* Constant (case insensitive) */
+#define PHPBN1a(x) %namewarn(%warningmsg(SWIGWARN_PARSE_BUILTIN_NAME, "enum conflicts with a built-in constant '"`x`"' in PHP"),%$isenumitem,sourcefmt="%(lower)s") `x`
+#define PHPBN1b(x) %namewarn(%warningmsg(SWIGWARN_PARSE_BUILTIN_NAME, "constant conflicts with a built-in constant '"`x`"' in PHP"),%$isconstant,sourcefmt="%(lower)s") `x`
+%define PHPBN1(X)
+ PHPBN1a(X); PHPBN1b(X)
+%enddef
+
+/* Constant (case sensitive) */
+#define PHPBN2a(x) %namewarn(%warningmsg(SWIGWARN_PARSE_BUILTIN_NAME, "enum conflicts with a built-in constant '"`x`"' in PHP"),%$isenumitem) `x`
+#define PHPBN2b(x) %namewarn(%warningmsg(SWIGWARN_PARSE_BUILTIN_NAME, "constant conflicts with a built-in constant '"`x`"' in PHP"),%$isconstant) `x`
+%define PHPBN2(X)
+ PHPBN2a(X); PHPBN2b(X)
+%enddef
+
+#define PHPFN(x) %keywordwarn("'" `x` "' is a PHP built-in function, renaming to 'c_" `x` "'",sourcefmt="%(lower)s",%$isfunction,%$not %$ismember,rename="c_%s") `x`
+
+/* From: http://php.net/manual/en/reserved.keywords.php
+ * "You cannot use any of the following words as constants, class names,
+ * function or method names. Using them as variable names is generally OK, but
+ * could lead to confusion."
+ */
+/* Check is case insensitive - these *MUST* be listed in lower case here */
+PHPKW(__halt_compiler);
+PHPKW(abstract);
+PHPKW(and);
+PHPKW(array);
+PHPKW(as);
+PHPKW(break);
+PHPKW(callable); // As of PHP 5.4
+PHPKW(case);
+PHPKW(catch);
+PHPKW(class);
+PHPKW(clone);
+PHPKW(const);
+PHPKW(continue);
+PHPKW(declare);
+PHPKW(default);
+PHPKW(die); // "Language construct"
+PHPKW(do);
+PHPKW(echo); // "Language construct"
+PHPKW(else);
+PHPKW(elseif);
+PHPKW(empty); // "Language construct"
+PHPKW(enddeclare);
+PHPKW(endfor);
+PHPKW(endforeach);
+PHPKW(endif);
+PHPKW(endswitch);
+PHPKW(endwhile);
+PHPKW(eval); // "Language construct"
+PHPKW(exit); // "Language construct"
+PHPKW(extends);
+PHPKW(final);
+PHPKW(finally); // As of PHP 5.5
+PHPKW(for);
+PHPKW(foreach);
+PHPKW(function);
+PHPKW(global);
+PHPKW(goto); // As of PHP 5.3
+PHPKW(if);
+PHPKW(implements);
+PHPKW(include); // "Language construct"
+PHPKW(include_once); // "Language construct"
+PHPKW(instanceof);
+PHPKW(insteadof); // As of PHP 5.4
+PHPKW(interface);
+PHPKW(isset); // "Language construct"
+PHPKW(list); // "Language construct"
+PHPKW(namespace); // As of PHP 5.3
+PHPKW(new);
+PHPKW(or);
+PHPKW(print); // "Language construct"
+PHPKW(private);
+PHPKW(protected);
+PHPKW(public);
+PHPKW(require); // "Language construct"
+PHPKW(require_once); // "Language construct"
+PHPKW(return); // "Language construct"
+PHPKW(static);
+PHPKW(switch);
+PHPKW(throw);
+PHPKW(trait); // As of PHP 5.4
+PHPKW(try);
+PHPKW(unset); // "Language construct"
+PHPKW(use);
+PHPKW(var);
+PHPKW(while);
+PHPKW(xor);
+PHPKW(yield); // As of PHP 5.5
+
+// Compile-time "magic" constants
+// From: http://php.net/manual/en/reserved.keywords.php
+// also at: http://php.net/manual/en/language.constants.predefined.php
+/* These *MUST* be listed in lower case here */
+PHPKW(__class__);
+PHPKW(__dir__); // As of PHP 5.3
+PHPKW(__file__);
+PHPKW(__function__);
+PHPKW(__line__);
+PHPKW(__method__);
+PHPKW(__namespace__); // As of PHP 5.3
+PHPKW(__trait__); // As of PHP 5.4
+
+/* We classify these as built-in names since they conflict, but PHP still runs */
+
+/* Predefined case-insensitive constants */
+/* These *MUST* be listed in lower case here */
+PHPBN1(null);
+PHPBN1(true);
+PHPBN1(false);
+
+/* "Core Predefined Constants" from http://php.net/manual/en/reserved.constants.php */
+/* These are case sensitive */
+PHPBN2(PHP_VERSION);
+PHPBN2(PHP_MAJOR_VERSION); // As of PHP 5.2.7
+PHPBN2(PHP_MINOR_VERSION); // As of PHP 5.2.7
+PHPBN2(PHP_RELEASE_VERSION); // As of PHP 5.2.7
+PHPBN2(PHP_VERSION_ID); // As of PHP 5.2.7
+PHPBN2(PHP_EXTRA_VERSION); // As of PHP 5.2.7
+PHPBN2(PHP_ZTS); // As of PHP 5.2.7
+PHPBN2(PHP_DEBUG); // As of PHP 5.2.7
+PHPBN2(PHP_MAXPATHLEN); // As of PHP 5.3.0
+PHPBN2(PHP_OS);
+PHPBN2(PHP_SAPI);
+PHPBN2(PHP_EOL); // As of PHP 5.0.2
+PHPBN2(PHP_INT_MAX); // As of PHP 5.0.5
+PHPBN2(PHP_INT_SIZE); // As of PHP 5.0.5
+PHPBN2(DEFAULT_INCLUDE_PATH);
+PHPBN2(PEAR_INSTALL_DIR);
+PHPBN2(PEAR_EXTENSION_DIR);
+PHPBN2(PHP_EXTENSION_DIR);
+PHPBN2(PHP_PREFIX);
+PHPBN2(PHP_BINDIR);
+PHPBN2(PHP_BINARY); // As of PHP 5.4
+PHPBN2(PHP_MANDIR); // As of PHP 5.3.7
+PHPBN2(PHP_LIBDIR);
+PHPBN2(PHP_DATADIR);
+PHPBN2(PHP_SYSCONFDIR);
+PHPBN2(PHP_LOCALSTATEDIR);
+PHPBN2(PHP_CONFIG_FILE_PATH);
+PHPBN2(PHP_CONFIG_FILE_SCAN_DIR);
+PHPBN2(PHP_SHLIB_SUFFIX);
+PHPBN2(E_ERROR);
+PHPBN2(E_WARNING);
+PHPBN2(E_PARSE);
+PHPBN2(E_NOTICE);
+PHPBN2(E_CORE_ERROR);
+PHPBN2(E_CORE_WARNING);
+PHPBN2(E_COMPILE_ERROR);
+PHPBN2(E_COMPILE_WARNING);
+PHPBN2(E_USER_ERROR);
+PHPBN2(E_USER_WARNING);
+PHPBN2(E_USER_NOTICE);
+PHPBN2(E_DEPRECATED); // As of PHP 5.3.0
+PHPBN2(E_USER_DEPRECATED); // As of PHP 5.3.0
+PHPBN2(E_ALL);
+PHPBN2(E_STRICT);
+PHPBN2(__COMPILER_HALT_OFFSET__); // As of PHP 5.1.0
+// TRUE, FALSE, NULL are listed on the same page, but are actually
+// case-insensitive, whereas all the other constants listed there seem to be
+// case-sensitive, so we handle TRUE, FALSE, NULL in PHPBN1.
+PHPBN2(PHP_OUTPUT_HANDLER_START);
+PHPBN2(PHP_OUTPUT_HANDLER_CONT);
+PHPBN2(PHP_OUTPUT_HANDLER_END);
+/* These don't actually seem to be set (tested on Linux, I guess they're
+ * Windows only?) */
+PHPBN2(PHP_WINDOWS_NT_DOMAIN_CONTROLLER); // As of PHP 5.3
+PHPBN2(PHP_WINDOWS_NT_SERVER); // As of PHP 5.3
+PHPBN2(PHP_WINDOWS_NT_WORKSTATION); // As of PHP 5.3
+PHPBN2(PHP_WINDOWS_VERSION_BUILD); // As of PHP 5.3
+PHPBN2(PHP_WINDOWS_VERSION_MAJOR); // As of PHP 5.3
+PHPBN2(PHP_WINDOWS_VERSION_MINOR); // As of PHP 5.3
+PHPBN2(PHP_WINDOWS_VERSION_PLATFORM); // As of PHP 5.3
+PHPBN2(PHP_WINDOWS_VERSION_PRODUCTTYPE); // As of PHP 5.3
+PHPBN2(PHP_WINDOWS_VERSION_SP_MAJOR); // As of PHP 5.3
+PHPBN2(PHP_WINDOWS_VERSION_SP_MINOR); // As of PHP 5.3
+PHPBN2(PHP_WINDOWS_VERSION_SUITEMASK); // As of PHP 5.3
+/* "Standard Predefined Constants" from http://php.net/manual/en/reserved.constants.php */
+PHPBN2(EXTR_OVERWRITE);
+PHPBN2(EXTR_SKIP);
+PHPBN2(EXTR_PREFIX_SAME);
+PHPBN2(EXTR_PREFIX_ALL);
+PHPBN2(EXTR_PREFIX_INVALID);
+PHPBN2(EXTR_PREFIX_IF_EXISTS);
+PHPBN2(EXTR_IF_EXISTS);
+PHPBN2(SORT_ASC);
+PHPBN2(SORT_DESC);
+PHPBN2(SORT_REGULAR);
+PHPBN2(SORT_NUMERIC);
+PHPBN2(SORT_STRING);
+PHPBN2(CASE_LOWER);
+PHPBN2(CASE_UPPER);
+PHPBN2(COUNT_NORMAL);
+PHPBN2(COUNT_RECURSIVE);
+PHPBN2(ASSERT_ACTIVE);
+PHPBN2(ASSERT_CALLBACK);
+PHPBN2(ASSERT_BAIL);
+PHPBN2(ASSERT_WARNING);
+PHPBN2(ASSERT_QUIET_EVAL);
+PHPBN2(CONNECTION_ABORTED);
+PHPBN2(CONNECTION_NORMAL);
+PHPBN2(CONNECTION_TIMEOUT);
+PHPBN2(INI_USER);
+PHPBN2(INI_PERDIR);
+PHPBN2(INI_SYSTEM);
+PHPBN2(INI_ALL);
+PHPBN2(INI_SCANNER_NORMAL); // As of PHP 5.3
+PHPBN2(INI_SCANNER_RAW); // As of PHP 5.3
+PHPBN2(M_E);
+PHPBN2(M_LOG2E);
+PHPBN2(M_LOG10E);
+PHPBN2(M_LN2);
+PHPBN2(M_LN10);
+PHPBN2(M_PI);
+PHPBN2(M_PI_2);
+PHPBN2(M_PI_4);
+PHPBN2(M_1_PI);
+PHPBN2(M_2_PI);
+PHPBN2(M_2_SQRTPI);
+PHPBN2(M_SQRT2);
+PHPBN2(M_SQRT1_2);
+PHPBN2(M_EULER); // As of PHP 5.2
+PHPBN2(M_LNPI); // As of PHP 5.2
+PHPBN2(M_SQRT3); // As of PHP 5.2
+PHPBN2(M_SQRTPI); // As of PHP 5.2
+PHPBN2(CRYPT_SALT_LENGTH);
+PHPBN2(CRYPT_STD_DES);
+PHPBN2(CRYPT_EXT_DES);
+PHPBN2(CRYPT_MD5);
+PHPBN2(CRYPT_BLOWFISH);
+PHPBN2(DIRECTORY_SEPARATOR);
+PHPBN2(SEEK_SET);
+PHPBN2(SEEK_CUR);
+PHPBN2(SEEK_END);
+PHPBN2(LOCK_SH);
+PHPBN2(LOCK_EX);
+PHPBN2(LOCK_UN);
+PHPBN2(LOCK_NB);
+PHPBN2(HTML_SPECIALCHARS);
+PHPBN2(HTML_ENTITIES);
+PHPBN2(ENT_COMPAT);
+PHPBN2(ENT_QUOTES);
+PHPBN2(ENT_NOQUOTES);
+PHPBN2(INFO_GENERAL);
+PHPBN2(INFO_CREDITS);
+PHPBN2(INFO_CONFIGURATION);
+PHPBN2(INFO_MODULES);
+PHPBN2(INFO_ENVIRONMENT);
+PHPBN2(INFO_VARIABLES);
+PHPBN2(INFO_LICENSE);
+PHPBN2(INFO_ALL);
+PHPBN2(CREDITS_GROUP);
+PHPBN2(CREDITS_GENERAL);
+PHPBN2(CREDITS_SAPI);
+PHPBN2(CREDITS_MODULES);
+PHPBN2(CREDITS_DOCS);
+PHPBN2(CREDITS_FULLPAGE);
+PHPBN2(CREDITS_QA);
+PHPBN2(CREDITS_ALL);
+PHPBN2(STR_PAD_LEFT);
+PHPBN2(STR_PAD_RIGHT);
+PHPBN2(STR_PAD_BOTH);
+PHPBN2(PATHINFO_DIRNAME);
+PHPBN2(PATHINFO_BASENAME);
+PHPBN2(PATHINFO_EXTENSION);
+PHPBN2(PATHINFO_FILENAME); // As of PHP 5.2
+PHPBN2(PATH_SEPARATOR);
+PHPBN2(CHAR_MAX);
+PHPBN2(LC_CTYPE);
+PHPBN2(LC_NUMERIC);
+PHPBN2(LC_TIME);
+PHPBN2(LC_COLLATE);
+PHPBN2(LC_MONETARY);
+PHPBN2(LC_ALL);
+PHPBN2(LC_MESSAGES);
+PHPBN2(ABDAY_1);
+PHPBN2(ABDAY_2);
+PHPBN2(ABDAY_3);
+PHPBN2(ABDAY_4);
+PHPBN2(ABDAY_5);
+PHPBN2(ABDAY_6);
+PHPBN2(ABDAY_7);
+PHPBN2(DAY_1);
+PHPBN2(DAY_2);
+PHPBN2(DAY_3);
+PHPBN2(DAY_4);
+PHPBN2(DAY_5);
+PHPBN2(DAY_6);
+PHPBN2(DAY_7);
+PHPBN2(ABMON_1);
+PHPBN2(ABMON_2);
+PHPBN2(ABMON_3);
+PHPBN2(ABMON_4);
+PHPBN2(ABMON_5);
+PHPBN2(ABMON_6);
+PHPBN2(ABMON_7);
+PHPBN2(ABMON_8);
+PHPBN2(ABMON_9);
+PHPBN2(ABMON_10);
+PHPBN2(ABMON_11);
+PHPBN2(ABMON_12);
+PHPBN2(MON_1);
+PHPBN2(MON_2);
+PHPBN2(MON_3);
+PHPBN2(MON_4);
+PHPBN2(MON_5);
+PHPBN2(MON_6);
+PHPBN2(MON_7);
+PHPBN2(MON_8);
+PHPBN2(MON_9);
+PHPBN2(MON_10);
+PHPBN2(MON_11);
+PHPBN2(MON_12);
+PHPBN2(AM_STR);
+PHPBN2(PM_STR);
+PHPBN2(D_T_FMT);
+PHPBN2(D_FMT);
+PHPBN2(T_FMT);
+PHPBN2(T_FMT_AMPM);
+PHPBN2(ERA);
+PHPBN2(ERA_YEAR);
+PHPBN2(ERA_D_T_FMT);
+PHPBN2(ERA_D_FMT);
+PHPBN2(ERA_T_FMT);
+PHPBN2(ALT_DIGITS);
+PHPBN2(INT_CURR_SYMBOL);
+PHPBN2(CURRENCY_SYMBOL);
+PHPBN2(CRNCYSTR);
+PHPBN2(MON_DECIMAL_POINT);
+PHPBN2(MON_THOUSANDS_SEP);
+PHPBN2(MON_GROUPING);
+PHPBN2(POSITIVE_SIGN);
+PHPBN2(NEGATIVE_SIGN);
+PHPBN2(INT_FRAC_DIGITS);
+PHPBN2(FRAC_DIGITS);
+PHPBN2(P_CS_PRECEDES);
+PHPBN2(P_SEP_BY_SPACE);
+PHPBN2(N_CS_PRECEDES);
+PHPBN2(N_SEP_BY_SPACE);
+PHPBN2(P_SIGN_POSN);
+PHPBN2(N_SIGN_POSN);
+PHPBN2(DECIMAL_POINT);
+PHPBN2(RADIXCHAR);
+PHPBN2(THOUSANDS_SEP);
+PHPBN2(THOUSEP);
+PHPBN2(GROUPING);
+PHPBN2(YESEXPR);
+PHPBN2(NOEXPR);
+PHPBN2(YESSTR);
+PHPBN2(NOSTR);
+PHPBN2(CODESET);
+PHPBN2(LOG_EMERG);
+PHPBN2(LOG_ALERT);
+PHPBN2(LOG_CRIT);
+PHPBN2(LOG_ERR);
+PHPBN2(LOG_WARNING);
+PHPBN2(LOG_NOTICE);
+PHPBN2(LOG_INFO);
+PHPBN2(LOG_DEBUG);
+PHPBN2(LOG_KERN);
+PHPBN2(LOG_USER);
+PHPBN2(LOG_MAIL);
+PHPBN2(LOG_DAEMON);
+PHPBN2(LOG_AUTH);
+PHPBN2(LOG_SYSLOG);
+PHPBN2(LOG_LPR);
+PHPBN2(LOG_NEWS);
+PHPBN2(LOG_UUCP);
+PHPBN2(LOG_CRON);
+PHPBN2(LOG_AUTHPRIV);
+PHPBN2(LOG_LOCAL0);
+PHPBN2(LOG_LOCAL1);
+PHPBN2(LOG_LOCAL2);
+PHPBN2(LOG_LOCAL3);
+PHPBN2(LOG_LOCAL4);
+PHPBN2(LOG_LOCAL5);
+PHPBN2(LOG_LOCAL6);
+PHPBN2(LOG_LOCAL7);
+PHPBN2(LOG_PID);
+PHPBN2(LOG_CONS);
+PHPBN2(LOG_ODELAY);
+PHPBN2(LOG_NDELAY);
+PHPBN2(LOG_NOWAIT);
+PHPBN2(LOG_PERROR);
+
+/* Added in PHP 5.2 */
+PHPBN2(PREG_BACKTRACK_LIMIT_ERROR);
+PHPBN2(PREG_BAD_UTF8_ERROR);
+PHPBN2(PREG_INTERNAL_ERROR);
+PHPBN2(PREG_NO_ERROR);
+PHPBN2(PREG_RECURSION_LIMIT_ERROR);
+PHPBN2(UPLOAD_ERR_EXTENSION);
+PHPBN2(STREAM_SHUT_RD);
+PHPBN2(STREAM_SHUT_WR);
+PHPBN2(STREAM_SHUT_RDWR);
+PHPBN2(CURLE_FILESIZE_EXCEEDED);
+PHPBN2(CURLE_FTP_SSL_FAILED);
+PHPBN2(CURLE_LDAP_INVALID_URL);
+PHPBN2(CURLFTPAUTH_DEFAULT);
+PHPBN2(CURLFTPAUTH_SSL);
+PHPBN2(CURLFTPAUTH_TLS);
+PHPBN2(CURLFTPSSL_ALL);
+PHPBN2(CURLFTPSSL_CONTROL);
+PHPBN2(CURLFTPSSL_NONE);
+PHPBN2(CURLFTPSSL_TRY);
+PHPBN2(CURLOPT_FTP_SSL);
+PHPBN2(CURLOPT_FTPSSLAUTH);
+PHPBN2(CURLOPT_TCP_NODELAY); // Added in PHP 5.2.1
+PHPBN2(CURLOPT_TIMEOUT_MS); // Added in PHP 5.2.3
+PHPBN2(CURLOPT_CONNECTTIMEOUT_MS); // Added in PHP 5.2.3
+PHPBN2(GMP_VERSION); // Added in PHP 5.2.2
+PHPBN2(SWFTEXTFIELD_USEFONT);
+PHPBN2(SWFTEXTFIELD_AUTOSIZE);
+PHPBN2(SWF_SOUND_NOT_COMPRESSED);
+PHPBN2(SWF_SOUND_ADPCM_COMPRESSED);
+PHPBN2(SWF_SOUND_MP3_COMPRESSED);
+PHPBN2(SWF_SOUND_NOT_COMPRESSED_LE);
+PHPBN2(SWF_SOUND_NELLY_COMPRESSED);
+PHPBN2(SWF_SOUND_5KHZ);
+PHPBN2(SWF_SOUND_11KHZ);
+PHPBN2(SWF_SOUND_22KHZ);
+PHPBN2(SWF_SOUND_44KHZ);
+PHPBN2(SWF_SOUND_8BITS);
+PHPBN2(SWF_SOUND_16BITS);
+PHPBN2(SWF_SOUND_MONO);
+PHPBN2(SWF_SOUND_STEREO);
+PHPBN2(OPENSSL_VERSION_NUMBER);
+PHPBN2(SNMP_OID_OUTPUT_FULL);
+PHPBN2(SNMP_OID_OUTPUT_NUMERIC);
+PHPBN2(MSG_EAGAIN);
+PHPBN2(MSG_ENOMSG);
+
+/* Added in PHP 5.3 */
+PHPBN2(CURLOPT_PROGRESSFUNCTION);
+PHPBN2(IMG_FILTER_PIXELATE);
+PHPBN2(JSON_ERROR_CTRL_CHAR);
+PHPBN2(JSON_ERROR_DEPTH);
+PHPBN2(JSON_ERROR_NONE);
+PHPBN2(JSON_ERROR_STATE_MISMATCH);
+PHPBN2(JSON_ERROR_SYNTAX);
+PHPBN2(JSON_FORCE_OBJECT);
+PHPBN2(JSON_HEX_TAG);
+PHPBN2(JSON_HEX_AMP);
+PHPBN2(JSON_HEX_APOS);
+PHPBN2(JSON_HEX_QUOT);
+PHPBN2(LDAP_OPT_NETWORK_TIMEOUT);
+PHPBN2(LIBXML_LOADED_VERSION);
+PHPBN2(PREG_BAD_UTF8_OFFSET_ERROR);
+PHPBN2(BUS_ADRALN);
+PHPBN2(BUS_ADRERR);
+PHPBN2(BUS_OBJERR);
+PHPBN2(CLD_CONTIUNED);
+PHPBN2(CLD_DUMPED);
+PHPBN2(CLD_EXITED);
+PHPBN2(CLD_KILLED);
+PHPBN2(CLD_STOPPED);
+PHPBN2(CLD_TRAPPED);
+PHPBN2(FPE_FLTDIV);
+PHPBN2(FPE_FLTINV);
+PHPBN2(FPE_FLTOVF);
+PHPBN2(FPE_FLTRES);
+PHPBN2(FPE_FLTSUB);
+PHPBN2(FPE_FLTUND);
+PHPBN2(FPE_INTDIV);
+PHPBN2(FPE_INTOVF);
+PHPBN2(ILL_BADSTK);
+PHPBN2(ILL_COPROC);
+PHPBN2(ILL_ILLADR);
+PHPBN2(ILL_ILLOPC);
+PHPBN2(ILL_ILLOPN);
+PHPBN2(ILL_ILLTRP);
+PHPBN2(ILL_PRVOPC);
+PHPBN2(ILL_PRVREG);
+PHPBN2(POLL_ERR);
+PHPBN2(POLL_HUP);
+PHPBN2(POLL_IN);
+PHPBN2(POLL_MSG);
+PHPBN2(POLL_OUT);
+PHPBN2(POLL_PRI);
+PHPBN2(SEGV_ACCERR);
+PHPBN2(SEGV_MAPERR);
+PHPBN2(SI_ASYNCIO);
+PHPBN2(SI_KERNEL);
+PHPBN2(SI_MESGQ);
+PHPBN2(SI_NOINFO);
+PHPBN2(SI_QUEUE);
+PHPBN2(SI_SIGIO);
+PHPBN2(SI_TIMER);
+PHPBN2(SI_TKILL);
+PHPBN2(SI_USER);
+PHPBN2(SIG_BLOCK);
+PHPBN2(SIG_SETMASK);
+PHPBN2(SIG_UNBLOCK);
+PHPBN2(TRAP_BRKPT);
+PHPBN2(TRAP_TRACE);
+
+/* Added in PHP 5.4 */
+PHPBN2(ENT_DISALLOWED);
+PHPBN2(ENT_HTML401);
+PHPBN2(ENT_HTML5);
+PHPBN2(ENT_SUBSTITUTE);
+PHPBN2(ENT_XML1);
+PHPBN2(ENT_XHTML);
+PHPBN2(IPPROTO_IP);
+PHPBN2(IPPROTO_IPV6);
+PHPBN2(IPV6_MULTICAST_HOPS);
+PHPBN2(IPV6_MULTICAST_IF);
+PHPBN2(IPV6_MULTICAST_LOOP);
+PHPBN2(IP_MULTICAST_IF);
+PHPBN2(IP_MULTICAST_LOOP);
+PHPBN2(IP_MULTICAST_TTL);
+PHPBN2(MCAST_JOIN_GROUP);
+PHPBN2(MCAST_LEAVE_GROUP);
+PHPBN2(MCAST_BLOCK_SOURCE);
+PHPBN2(MCAST_UNBLOCK_SOURCE);
+PHPBN2(MCAST_JOIN_SOURCE_GROUP);
+PHPBN2(MCAST_LEAVE_SOURCE_GROUP);
+PHPBN2(CURLOPT_MAX_RECV_SPEED_LARGE);
+PHPBN2(CURLOPT_MAX_SEND_SPEED_LARGE);
+PHPBN2(LIBXML_HTML_NODEFDTD);
+PHPBN2(LIBXML_HTML_NOIMPLIED);
+PHPBN2(LIBXML_PEDANTIC);
+PHPBN2(OPENSSL_CIPHER_AES_128_CBC);
+PHPBN2(OPENSSL_CIPHER_AES_192_CBC);
+PHPBN2(OPENSSL_CIPHER_AES_256_CBC);
+PHPBN2(OPENSSL_RAW_DATA);
+PHPBN2(OPENSSL_ZERO_PADDING);
+PHPBN2(PHP_OUTPUT_HANDLER_CLEAN);
+PHPBN2(PHP_OUTPUT_HANDLER_CLEANABLE);
+PHPBN2(PHP_OUTPUT_HANDLER_DISABLED);
+PHPBN2(PHP_OUTPUT_HANDLER_FINAL);
+PHPBN2(PHP_OUTPUT_HANDLER_FLUSH);
+PHPBN2(PHP_OUTPUT_HANDLER_FLUSHABLE);
+PHPBN2(PHP_OUTPUT_HANDLER_REMOVABLE);
+PHPBN2(PHP_OUTPUT_HANDLER_STARTED);
+PHPBN2(PHP_OUTPUT_HANDLER_STDFLAGS);
+PHPBN2(PHP_OUTPUT_HANDLER_WRITE);
+PHPBN2(PHP_SESSION_ACTIVE);
+PHPBN2(PHP_SESSION_DISABLED);
+PHPBN2(PHP_SESSION_NONE);
+PHPBN2(STREAM_META_ACCESS);
+PHPBN2(STREAM_META_GROUP);
+PHPBN2(STREAM_META_GROUP_NAME);
+PHPBN2(STREAM_META_OWNER);
+PHPBN2(STREAM_META_OWNER_NAME);
+PHPBN2(STREAM_META_TOUCH);
+PHPBN2(ZLIB_ENCODING_DEFLATE);
+PHPBN2(ZLIB_ENCODING_GZIP);
+PHPBN2(ZLIB_ENCODING_RAW);
+PHPBN2(U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR);
+PHPBN2(IDNA_CHECK_BIDI);
+PHPBN2(IDNA_CHECK_CONTEXTJ);
+PHPBN2(IDNA_NONTRANSITIONAL_TO_ASCII);
+PHPBN2(IDNA_NONTRANSITIONAL_TO_UNICODE);
+PHPBN2(INTL_IDNA_VARIANT_2003);
+PHPBN2(INTL_IDNA_VARIANT_UTS46);
+PHPBN2(IDNA_ERROR_EMPTY_LABEL);
+PHPBN2(IDNA_ERROR_LABEL_TOO_LONG);
+PHPBN2(IDNA_ERROR_DOMAIN_NAME_TOO_LONG);
+PHPBN2(IDNA_ERROR_LEADING_HYPHEN);
+PHPBN2(IDNA_ERROR_TRAILING_HYPHEN);
+PHPBN2(IDNA_ERROR_HYPHEN_3_4);
+PHPBN2(IDNA_ERROR_LEADING_COMBINING_MARK);
+PHPBN2(IDNA_ERROR_DISALLOWED);
+PHPBN2(IDNA_ERROR_PUNYCODE);
+PHPBN2(IDNA_ERROR_LABEL_HAS_DOT);
+PHPBN2(IDNA_ERROR_INVALID_ACE_LABEL);
+PHPBN2(IDNA_ERROR_BIDI);
+PHPBN2(IDNA_ERROR_CONTEXTJ);
+PHPBN2(JSON_PRETTY_PRINT);
+PHPBN2(JSON_UNESCAPED_SLASHES);
+PHPBN2(JSON_NUMERIC_CHECK);
+PHPBN2(JSON_UNESCAPED_UNICODE);
+PHPBN2(JSON_BIGINT_AS_STRING);
+
+/* Added in PHP 5.5 */
+PHPBN2(IMG_AFFINE_TRANSLATE);
+PHPBN2(IMG_AFFINE_SCALE);
+PHPBN2(IMG_AFFINE_ROTATE);
+PHPBN2(IMG_AFFINE_SHEAR_HORIZONTAL);
+PHPBN2(IMG_AFFINE_SHEAR_VERTICAL);
+PHPBN2(IMG_CROP_DEFAULT);
+PHPBN2(IMG_CROP_TRANSPARENT);
+PHPBN2(IMG_CROP_BLACK);
+PHPBN2(IMG_CROP_WHITE);
+PHPBN2(IMG_CROP_SIDES);
+PHPBN2(IMG_FLIP_BOTH);
+PHPBN2(IMG_FLIP_HORIZONTAL);
+PHPBN2(IMG_FLIP_VERTICAL);
+PHPBN2(IMG_BELL);
+PHPBN2(IMG_BESSEL);
+PHPBN2(IMG_BICUBIC);
+PHPBN2(IMG_BICUBIC_FIXED);
+PHPBN2(IMG_BLACKMAN);
+PHPBN2(IMG_BOX);
+PHPBN2(IMG_BSPLINE);
+PHPBN2(IMG_CATMULLROM);
+PHPBN2(IMG_GAUSSIAN);
+PHPBN2(IMG_GENERALIZED_CUBIC);
+PHPBN2(IMG_HERMITE);
+PHPBN2(IMG_HAMMING);
+PHPBN2(IMG_HANNING);
+PHPBN2(IMG_MITCHELL);
+PHPBN2(IMG_POWER);
+PHPBN2(IMG_QUADRATIC);
+PHPBN2(IMG_SINC);
+PHPBN2(IMG_NEAREST_NEIGHBOUR);
+PHPBN2(IMG_WEIGHTED4);
+PHPBN2(IMG_TRIANGLE);
+PHPBN2(JSON_ERROR_RECURSION);
+PHPBN2(JSON_ERROR_INF_OR_NAN);
+PHPBN2(JSON_ERROR_UNSUPPORTED_TYPE);
+PHPBN2(MYSQLI_SERVER_PUBLIC_KEY);
+
+/* Added in PHP 5.6 */
+PHPBN2(LDAP_ESCAPE_DN);
+PHPBN2(LDAP_ESCAPE_FILTER);
+PHPBN2(OPENSSL_DEFAULT_STREAM_CIPHERS);
+PHPBN2(STREAM_CRYPTO_METHOD_ANY_CLIENT);
+PHPBN2(STREAM_CRYPTO_METHOD_ANY_SERVER);
+PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT);
+PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_0_SERVER);
+PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT);
+PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_1_SERVER);
+PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT);
+PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_2_SERVER);
+PHPBN2(PGSQL_CONNECT_ASYNC);
+PHPBN2(PGSQL_CONNECTION_AUTH_OK);
+PHPBN2(PGSQL_CONNECTION_AWAITING_RESPONSE);
+PHPBN2(PGSQL_CONNECTION_MADE);
+PHPBN2(PGSQL_CONNECTION_SETENV);
+PHPBN2(PGSQL_CONNECTION_SSL_STARTUP);
+PHPBN2(PGSQL_CONNECTION_STARTED);
+PHPBN2(PGSQL_DML_ESCAPE);
+PHPBN2(PGSQL_POLLING_ACTIVE);
+PHPBN2(PGSQL_POLLING_FAILED);
+PHPBN2(PGSQL_POLLING_OK);
+PHPBN2(PGSQL_POLLING_READING);
+PHPBN2(PGSQL_POLLING_WRITING);
+
+/* Class names reserved by PHP (case insensitive) */
+PHPCN(directory);
+PHPCN(stdclass);
+PHPCN(__php_incomplete_class);
+/* Added in PHP5. */
+PHPCN(exception);
+PHPCN(errorexception); // As of PHP 5.1
+PHPCN(php_user_filter);
+PHPCN(closure); // As of PHP 5.3
+PHPCN(generator); // As of PHP 5.5
+PHPCN(self);
+PHPCN(static);
+PHPCN(parent);
+/* From extensions (which of these are actually predefined depends which
+ * extensions are loaded by default). */
+PHPCN(xmlwriter);
+PHPCN(libxmlerror);
+PHPCN(simplexmlelement);
+PHPCN(soapclient);
+PHPCN(soapvar);
+PHPCN(soapserver);
+PHPCN(soapfault);
+PHPCN(soapparam);
+PHPCN(soapheader);
+PHPCN(recursiveiteratoriterator);
+PHPCN(filteriterator);
+PHPCN(recursivefilteriterator);
+PHPCN(parentiterator);
+PHPCN(limititerator);
+PHPCN(cachingiterator);
+PHPCN(recursivecachingiterator);
+PHPCN(iteratoriterator);
+PHPCN(norewinditerator);
+PHPCN(appenditerator);
+PHPCN(infiniteiterator);
+PHPCN(emptyiterator);
+PHPCN(arrayobject);
+PHPCN(arrayiterator);
+PHPCN(recursivearrayiterator);
+PHPCN(splfileinfo);
+PHPCN(directoryiterator);
+PHPCN(recursivedirectoryiterator);
+PHPCN(splfileobject);
+PHPCN(spltempfileobject);
+PHPCN(simplexmliterator);
+PHPCN(logicexception);
+PHPCN(badfunctioncallexception);
+PHPCN(badmethodcallexception);
+PHPCN(domainexception);
+PHPCN(invalidargumentexception);
+PHPCN(lengthexception);
+PHPCN(outofrangeexception);
+PHPCN(runtimeexception);
+PHPCN(outofboundsexception);
+PHPCN(overflowexception);
+PHPCN(rangeexception);
+PHPCN(underflowexception);
+PHPCN(unexpectedvalueexception);
+PHPCN(splobjectstorage);
+PHPCN(reflectionexception);
+PHPCN(reflection);
+PHPCN(reflectionfunction);
+PHPCN(reflectionparameter);
+PHPCN(reflectionmethod);
+PHPCN(reflectionclass);
+PHPCN(reflectionobject);
+PHPCN(reflectionproperty);
+PHPCN(reflectionextension);
+PHPCN(domexception);
+PHPCN(domstringlist);
+PHPCN(domnamelist);
+PHPCN(domimplementationlist);
+PHPCN(domimplementationsource);
+PHPCN(domimplementation);
+PHPCN(domnode);
+PHPCN(domnamespacenode);
+PHPCN(domdocumentfragment);
+PHPCN(domdocument);
+PHPCN(domnodelist);
+PHPCN(domnamednodemap);
+PHPCN(domcharacterdata);
+PHPCN(domattr);
+PHPCN(domelement);
+PHPCN(domtext);
+PHPCN(domcomment);
+PHPCN(domtypeinfo);
+PHPCN(domuserdatahandler);
+PHPCN(domdomerror);
+PHPCN(domerrorhandler);
+PHPCN(domlocator);
+PHPCN(domconfiguration);
+PHPCN(domcdatasection);
+PHPCN(domdocumenttype);
+PHPCN(domnotation);
+PHPCN(domentity);
+PHPCN(domentityreference);
+PHPCN(domprocessinginstruction);
+PHPCN(domstringextend);
+PHPCN(domxpath);
+PHPCN(xmlreader);
+PHPCN(sqlitedatabase);
+PHPCN(sqliteresult);
+PHPCN(sqliteunbuffered);
+PHPCN(sqliteexception);
+PHPCN(datetime);
+
+/* Built-in PHP functions (incomplete). */
+/* Includes Array Functions - http://php.net/manual/en/ref.array.php */
+/* Check is case insensitive - these *MUST* be listed in lower case here */
+PHPFN(acos);
+PHPFN(array_change_key_case);
+PHPFN(array_chunk);
+PHPFN(array_column);
+PHPFN(array_combine);
+PHPFN(array_count_values);
+PHPFN(array_diff);
+PHPFN(array_diff_assoc);
+PHPFN(array_diff_key);
+PHPFN(array_diff_uassoc);
+PHPFN(array_diff_ukey);
+PHPFN(array_fill);
+PHPFN(array_fill_keys);
+PHPFN(array_filter);
+PHPFN(array_flip);
+PHPFN(array_intersect);
+PHPFN(array_intersect_assoc);
+PHPFN(array_intersect_key);
+PHPFN(array_intersect_uassoc);
+PHPFN(array_intersect_ukey);
+PHPFN(array_key_exists);
+PHPFN(array_keys);
+PHPFN(array_map);
+PHPFN(array_merge);
+PHPFN(array_merge_recursive);
+PHPFN(array_multisort);
+PHPFN(array_pad);
+PHPFN(array_pop);
+PHPFN(array_product);
+PHPFN(array_push);
+PHPFN(array_rand);
+PHPFN(array_reduce);
+PHPFN(array_replace);
+PHPFN(array_replace_recursive);
+PHPFN(array_reverse);
+PHPFN(array_search);
+PHPFN(array_shift);
+PHPFN(array_slice);
+PHPFN(array_splice);
+PHPFN(array_sum);
+PHPFN(array_udiff);
+PHPFN(array_udiff_assoc);
+PHPFN(array_udiff_uassoc);
+PHPFN(array_uintersect);
+PHPFN(array_uintersect_assoc);
+PHPFN(array_uintersect_uassoc);
+PHPFN(array_unique);
+PHPFN(array_unshift);
+PHPFN(array_values);
+PHPFN(array_walk);
+PHPFN(array_walk_recursive);
+PHPFN(arsort);
+PHPFN(asin);
+PHPFN(asort);
+PHPFN(atan);
+PHPFN(atan2);
+PHPFN(ceil);
+PHPFN(compact);
+PHPFN(cos);
+PHPFN(cosh);
+PHPFN(count);
+PHPFN(current);
+PHPFN(each);
+PHPFN(end);
+PHPFN(exp);
+PHPFN(extract);
+PHPFN(floor);
+PHPFN(fmod);
+PHPFN(in_array);
+PHPFN(key);
+PHPFN(key_exists);
+PHPFN(krsort);
+PHPFN(ksort);
+PHPFN(log);
+PHPFN(log10);
+PHPFN(max);
+PHPFN(min);
+PHPFN(natcasesort);
+PHPFN(natsort);
+PHPFN(next);
+PHPFN(pos);
+PHPFN(pow);
+PHPFN(prev);
+PHPFN(range);
+PHPFN(reset);
+PHPFN(rsort);
+PHPFN(shuffle);
+PHPFN(sin);
+PHPFN(sinh);
+PHPFN(sizeof);
+PHPFN(sort);
+PHPFN(sqrt);
+PHPFN(tan);
+PHPFN(tanh);
+PHPFN(uasort);
+PHPFN(uksort);
+PHPFN(usort);
+
+#undef PHPKW
+#undef PHPBN1a
+#undef PHPBN1b
+#undef PHPBN1
+#undef PHPBN2a
+#undef PHPBN2b
+#undef PHPBN2
+#undef PHPCN
+#undef PHPFN
diff --git a/share/swig/3.0.12/php5/phppointers.i b/share/swig/3.0.12/php5/phppointers.i
new file mode 100644
index 0000000..e50ada7
--- /dev/null
+++ b/share/swig/3.0.12/php5/phppointers.i
@@ -0,0 +1,42 @@
+%define %pass_by_ref( TYPE, CONVERT_IN, CONVERT_OUT )
+%typemap(in, byref=1) TYPE *REF ($*1_ltype tmp),
+             TYPE &REF ($*1_ltype tmp)
+%{
+  /* First Check for SWIG wrapped type */
+  if ( ZVAL_IS_NULL( *$input ) ) {
+      $1 = 0;
+  } else if ( PZVAL_IS_REF( *$input ) ) {
+      /* Not swig wrapped type, so we check if it's a PHP reference type */
+      CONVERT_IN( tmp, $*1_ltype, $input );
+      $1 = &tmp;
+  } else {
+      SWIG_PHP_Error( E_ERROR, SWIG_PHP_Arg_Error_Msg($argnum, Expected a reference) );
+  }
+%}
+%typemap(argout) TYPE *REF,
+                 TYPE &REF
+  "CONVERT_OUT(*$input, tmp$argnum );";
+%enddef
+
+%pass_by_ref( size_t, CONVERT_INT_IN, ZVAL_LONG );
+
+%pass_by_ref( signed int, CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( int, CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( unsigned int, CONVERT_INT_IN, ZVAL_LONG );
+
+%pass_by_ref( signed short, CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( short, CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( unsigned short, CONVERT_INT_IN, ZVAL_LONG );
+
+%pass_by_ref( signed long, CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( long, CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( unsigned long, CONVERT_INT_IN, ZVAL_LONG );
+
+%pass_by_ref( signed char, CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( char, CONVERT_CHAR_IN, ZVAL_STRING );
+%pass_by_ref( unsigned char, CONVERT_INT_IN, ZVAL_LONG );
+
+%pass_by_ref( float, CONVERT_FLOAT_IN, ZVAL_DOUBLE );
+%pass_by_ref( double, CONVERT_FLOAT_IN, ZVAL_DOUBLE );
+
+%pass_by_ref( char *, CONVERT_CHAR_IN, ZVAL_STRING );
diff --git a/share/swig/3.0.12/php5/phprun.swg b/share/swig/3.0.12/php5/phprun.swg
new file mode 100644
index 0000000..a18e1fc
--- /dev/null
+++ b/share/swig/3.0.12/php5/phprun.swg
@@ -0,0 +1,280 @@
+/* -----------------------------------------------------------------------------
+ * phprun.swg
+ *
+ * PHP runtime library
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "zend.h"
+#include "zend_API.h"
+#include "zend_exceptions.h"
+#include "php.h"
+
+#if PHP_MAJOR_VERSION != 5
+# error These bindings need PHP5 - to generate PHP7 bindings use: swig -php7
+#endif
+
+#include "ext/standard/php_string.h"
+#include <stdlib.h> /* for abort(), used in generated code. */
+
+#ifdef ZEND_RAW_FENTRY
+/* ZEND_RAW_FENTRY was added somewhere between 5.2.0 and 5.2.3 */
+# define SWIG_ZEND_NAMED_FE(ZN, N, A) ZEND_RAW_FENTRY((char*)#ZN, N, A, 0)
+#else
+/* This causes warnings from GCC >= 4.2 (assigning a string literal to char*).
+ * But this seems to be unavoidable without directly assuming knowledge of
+ * the structure, which changed between PHP4 and PHP5. */
+# define SWIG_ZEND_NAMED_FE(ZN, N, A) ZEND_NAMED_FE(ZN, N, A)
+#endif
+
+#ifndef ZEND_FE_END
+# define ZEND_FE_END { NULL, NULL, NULL }
+#endif
+
+#ifndef Z_SET_ISREF_P
+/* For PHP < 5.3 */
+# define Z_SET_ISREF_P(z) (z)->is_ref = 1
+#endif
+#ifndef Z_SET_REFCOUNT_P
+/* For PHP < 5.3 */
+# define Z_SET_REFCOUNT_P(z, rc) (z)->refcount = (rc)
+#endif
+
+#define SWIG_LONG_CONSTANT(N, V) zend_register_long_constant((char*)#N, sizeof(#N), V, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC)
+#define SWIG_DOUBLE_CONSTANT(N, V) zend_register_double_constant((char*)#N, sizeof(#N), V, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC)
+#define SWIG_STRING_CONSTANT(N, V) zend_register_stringl_constant((char*)#N, sizeof(#N), (char*)(V), strlen(V), CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC)
+#define SWIG_CHAR_CONSTANT(N, V) do {\
+    static char swig_char = (V);\
+    zend_register_stringl_constant((char*)#N, sizeof(#N), &swig_char, 1, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC);\
+} while (0)
+
+/* These TSRMLS_ stuff should already be defined now, but with older php under
+   redhat are not... */
+#ifndef TSRMLS_D
+#define TSRMLS_D
+#endif
+#ifndef TSRMLS_DC
+#define TSRMLS_DC
+#endif
+#ifndef TSRMLS_C
+#define TSRMLS_C
+#endif
+#ifndef TSRMLS_CC
+#define TSRMLS_CC
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+/* But in fact SWIG_ConvertPtr is the native interface for getting typed
+   pointer values out of zvals.  We need the TSRMLS_ macros for when we
+   make PHP type calls later as we handle php resources */
+#define SWIG_ConvertPtr(obj,pp,type,flags) SWIG_ZTS_ConvertPtr(obj,pp,type,flags TSRMLS_CC)
+
+
+#define SWIG_fail goto fail
+
+static const char *default_error_msg = "Unknown error occurred";
+static int default_error_code = E_ERROR;
+
+#define SWIG_PHP_Arg_Error_Msg(argnum,extramsg) "Error in argument " #argnum " "#extramsg
+
+#define SWIG_PHP_Error(code,msg) do { SWIG_ErrorCode() = code; SWIG_ErrorMsg() = msg; SWIG_fail; } while (0)
+
+#define SWIG_contract_assert(expr,msg) \
+  if (!(expr) ) { zend_printf("Contract Assert Failed %s\n",msg ); } else
+
+/* Standard SWIG API */
+#define SWIG_GetModule(clientdata) SWIG_Php_GetModule()
+#define SWIG_SetModule(clientdata, pointer) SWIG_Php_SetModule(pointer)
+
+/* used to wrap returned objects in so we know whether they are newobject
+   and need freeing, or not */
+typedef struct {
+  void * ptr;
+  int newobject;
+} swig_object_wrapper;
+
+#define SWIG_SetPointerZval(a,b,c,d) SWIG_ZTS_SetPointerZval(a,b,c,d TSRMLS_CC)
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
+
+static void
+SWIG_ZTS_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject TSRMLS_DC) {
+  /*
+   * First test for Null pointers.  Return those as PHP native NULL
+   */
+  if (!ptr ) {
+    ZVAL_NULL(z);
+    return;
+  }
+  if (type->clientdata) {
+    swig_object_wrapper *value;
+    if (! (*(int *)(type->clientdata)))
+      zend_error(E_ERROR, "Type: %s failed to register with zend",type->name);
+    value=(swig_object_wrapper *)emalloc(sizeof(swig_object_wrapper));
+    value->ptr=ptr;
+    value->newobject=(newobject & 1);
+    if ((newobject & 2) == 0) {
+      /* Just register the pointer as a resource. */
+      ZEND_REGISTER_RESOURCE(z, value, *(int *)(type->clientdata));
+    } else {
+      /*
+       * Wrap the resource in an object, the resource will be accessible
+       * via the "_cPtr" member. This is currently only used by
+       * directorin typemaps.
+       */
+      zval *resource;
+      zend_class_entry **ce = NULL;
+      const char *type_name = type->name+3; /* +3 so: _p_Foo -> Foo */
+      size_t type_name_len;
+      int result;
+      const char * p;
+
+      /* Namespace__Foo -> Foo */
+      /* FIXME: ugly and goes wrong for classes with __ in their names. */
+      while ((p = strstr(type_name, "__")) != NULL) {
+        type_name = p + 2;
+      }
+      type_name_len = strlen(type_name);
+
+      MAKE_STD_ZVAL(resource);
+      ZEND_REGISTER_RESOURCE(resource, value, *(int *)(type->clientdata));
+      if (SWIG_PREFIX_LEN > 0) {
+        char * classname = (char*)emalloc(SWIG_PREFIX_LEN + type_name_len + 1);
+        strcpy(classname, SWIG_PREFIX);
+        strcpy(classname + SWIG_PREFIX_LEN, type_name);
+        result = zend_lookup_class(classname, SWIG_PREFIX_LEN + type_name_len, &ce TSRMLS_CC);
+        efree(classname);
+      } else {
+        result = zend_lookup_class((char *)type_name, type_name_len, &ce TSRMLS_CC);
+      }
+      if (result != SUCCESS) {
+        /* class does not exist */
+        object_init(z);
+      } else {
+        object_init_ex(z, *ce);
+      }
+      Z_SET_REFCOUNT_P(z, 1);
+      Z_SET_ISREF_P(z);
+      zend_hash_update(HASH_OF(z), (char*)"_cPtr", sizeof("_cPtr"), (void*)&resource, sizeof(zval*), NULL);
+    }
+    return;
+  }
+  zend_error(E_ERROR, "Type: %s not registered with zend",type->name);
+}
+
+/* This pointer conversion routine takes the native pointer p (along with
+   its type name) and converts it by calling appropriate casting functions
+   according to ty.  The resultant pointer is returned, or NULL is returned
+   if the pointer can't be cast.
+
+   Sadly PHP has no API to find a type name from a type id, only from an
+   instance of a resource of the type id, so we have to pass type_name as well.
+
+   The two functions which might call this are:
+   SWIG_ZTS_ConvertResourcePtr which gets the type name from the resource
+   and the registered zend destructors for which we have one per type each
+   with the type name hard wired in. */
+static void *
+SWIG_ZTS_ConvertResourceData(void * p, const char *type_name, swig_type_info *ty TSRMLS_DC) {
+  swig_cast_info *tc;
+  void *result = 0;
+
+  if (!ty) {
+    /* They don't care about the target type, so just pass on the pointer! */
+    return p;
+  }
+
+  if (! type_name) {  
+    /* can't convert p to ptr type ty if we don't know what type p is */
+    return NULL;
+  }
+
+  /* convert and cast p from type_name to ptr as ty. */
+  tc = SWIG_TypeCheck(type_name, ty);
+  if (tc) {
+    int newmemory = 0;
+    result = SWIG_TypeCast(tc, p, &newmemory);
+    assert(!newmemory); /* newmemory handling not yet implemented */
+  }
+  return result;
+}
+
+/* This function returns a pointer of type ty by extracting the pointer
+   and type info from the resource in z.  z must be a resource.
+   If it fails, NULL is returned.
+   It uses SWIG_ZTS_ConvertResourceData to do the real work. */
+static void *
+SWIG_ZTS_ConvertResourcePtr(zval *z, swig_type_info *ty, int flags TSRMLS_DC) {
+  swig_object_wrapper *value;
+  void *p;
+  int type;
+  const char *type_name;
+
+  value = (swig_object_wrapper *) zend_list_find(z->value.lval, &type);
+  if (type==-1) return NULL;
+  if (flags & SWIG_POINTER_DISOWN) {
+    value->newobject = 0;
+  }
+  p = value->ptr;
+
+  type_name=zend_rsrc_list_get_rsrc_type(z->value.lval TSRMLS_CC);
+
+  return SWIG_ZTS_ConvertResourceData(p, type_name, ty TSRMLS_CC);
+}
+
+/* We allow passing of a RESOURCE pointing to the object or an OBJECT whose
+   _cPtr is a resource pointing to the object */
+static int
+SWIG_ZTS_ConvertPtr(zval *z, void **ptr, swig_type_info *ty, int flags TSRMLS_DC) {
+  if (z == NULL) {
+    *ptr = 0;
+    return 0;
+  }
+
+  switch (z->type) {
+    case IS_OBJECT: {
+      zval ** _cPtr;
+      if (zend_hash_find(HASH_OF(z),(char*)"_cPtr",sizeof("_cPtr"),(void**)&_cPtr)==SUCCESS) {
+	if ((*_cPtr)->type==IS_RESOURCE) {
+	  *ptr = SWIG_ZTS_ConvertResourcePtr(*_cPtr, ty, flags TSRMLS_CC);
+	  return (*ptr == NULL ? -1 : 0);
+	}
+      }
+      break;
+    }
+    case IS_RESOURCE:
+      *ptr = SWIG_ZTS_ConvertResourcePtr(z, ty, flags TSRMLS_CC);
+      return (*ptr == NULL ? -1 : 0);
+    case IS_NULL:
+      *ptr = 0;
+      return 0;
+  }
+
+  return -1;
+}
+
+static char const_name[] = "swig_runtime_data_type_pointer";
+static swig_module_info *SWIG_Php_GetModule() {
+  zval *pointer;
+  swig_module_info *ret = 0;
+  TSRMLS_FETCH();
+
+  MAKE_STD_ZVAL(pointer);
+
+  if (zend_get_constant(const_name, sizeof(const_name) - 1, pointer TSRMLS_CC)) {
+    if (pointer->type == IS_LONG) {
+      ret = (swig_module_info *) pointer->value.lval;
+    }
+  } 
+  FREE_ZVAL(pointer);
+  return ret; 
+}
+
+static void SWIG_Php_SetModule(swig_module_info *pointer) {
+  TSRMLS_FETCH();
+  REGISTER_MAIN_LONG_CONSTANT(const_name, (long) pointer, CONST_PERSISTENT | CONST_CS);
+}
diff --git a/share/swig/3.0.12/php5/std_common.i b/share/swig/3.0.12/php5/std_common.i
new file mode 100644
index 0000000..092bf01
--- /dev/null
+++ b/share/swig/3.0.12/php5/std_common.i
@@ -0,0 +1,10 @@
+/* -----------------------------------------------------------------------------
+ * std_common.i
+ *
+ * SWIG typemaps for STL - common utilities
+ * ----------------------------------------------------------------------------- */
+
+%include <std/std_except.i>
+
+%apply size_t { std::size_t };
+
diff --git a/share/swig/3.0.12/php5/std_deque.i b/share/swig/3.0.12/php5/std_deque.i
new file mode 100644
index 0000000..cb98f6c
--- /dev/null
+++ b/share/swig/3.0.12/php5/std_deque.i
@@ -0,0 +1 @@
+%include <std/_std_deque.i>
diff --git a/share/swig/3.0.12/php5/std_map.i b/share/swig/3.0.12/php5/std_map.i
new file mode 100644
index 0000000..6d5e3db
--- /dev/null
+++ b/share/swig/3.0.12/php5/std_map.i
@@ -0,0 +1,76 @@
+/* -----------------------------------------------------------------------------
+ * 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;
+        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();
+            }
+            bool is_empty() const {
+                return self->empty();
+            }
+        }
+    };
+
+// 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/3.0.12/php5/std_pair.i b/share/swig/3.0.12/php5/std_pair.i
new file mode 100644
index 0000000..fe45ee6
--- /dev/null
+++ b/share/swig/3.0.12/php5/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/3.0.12/php5/std_string.i b/share/swig/3.0.12/php5/std_string.i
new file mode 100644
index 0000000..aaa5dc9
--- /dev/null
+++ b/share/swig/3.0.12/php5/std_string.i
@@ -0,0 +1,79 @@
+/* -----------------------------------------------------------------------------
+ * std_string.i
+ *
+ * SWIG typemaps for std::string types
+ * ----------------------------------------------------------------------------- */
+
+// ------------------------------------------------------------------------
+// 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>
+
+%{
+#include <string>
+%}
+
+namespace std {
+
+    %naturalvar string;
+
+    class string;
+
+    %typemap(typecheck,precedence=SWIG_TYPECHECK_STRING) string, const string& %{
+        $1 = ( Z_TYPE_PP($input) == IS_STRING ) ? 1 : 0;
+    %}
+
+    %typemap(in) string %{
+        convert_to_string_ex($input);
+        $1.assign(Z_STRVAL_PP($input), Z_STRLEN_PP($input));
+    %}
+
+    %typemap(directorout) string %{
+        convert_to_string_ex(&$input);
+        $result.assign(Z_STRVAL_P($input), Z_STRLEN_P($input));
+    %}
+
+    %typemap(out) string %{
+        ZVAL_STRINGL($result, const_cast<char*>($1.data()), $1.size(), 1);
+    %}
+
+    %typemap(directorin) string, const string& %{
+        ZVAL_STRINGL($input, const_cast<char*>($1.data()), $1.size(), 1);
+    %}
+
+    %typemap(out) const string & %{
+        ZVAL_STRINGL($result, const_cast<char*>($1->data()), $1->size(), 1);
+    %}
+
+    %typemap(throws) string, const string& %{
+        zend_throw_exception(NULL, const_cast<char*>($1.c_str()), 0 TSRMLS_CC);
+        return;
+    %}
+
+    /* These next two handle a function which takes a non-const reference to
+     * a std::string and modifies the string. */
+    %typemap(in) string & ($*1_ltype temp) %{
+        convert_to_string_ex($input);
+        temp.assign(Z_STRVAL_PP($input), Z_STRLEN_PP($input));
+        $1 = &temp;
+    %}
+
+    %typemap(directorout) string & ($*1_ltype *temp) %{
+        convert_to_string_ex(&$input);
+        temp = new $*1_ltype(Z_STRVAL_P($input), Z_STRLEN_P($input));
+        swig_acquire_ownership(temp);
+        $result = temp;
+    %}
+
+    %typemap(argout) string & %{
+	ZVAL_STRINGL(*($input), const_cast<char*>($1->data()), $1->size(), 1);
+    %}
+
+    /* SWIG will apply the non-const typemap above to const string& without
+     * this more specific typemap. */
+    %typemap(argout) const string & "";
+}
diff --git a/share/swig/3.0.12/php5/std_vector.i b/share/swig/3.0.12/php5/std_vector.i
new file mode 100644
index 0000000..9cc1486
--- /dev/null
+++ b/share/swig/3.0.12/php5/std_vector.i
@@ -0,0 +1,102 @@
+/* -----------------------------------------------------------------------------
+ * std_vector.i
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.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);
+    void clear();
+    %rename(push) push_back;
+    void push_back(const value_type& x);
+    %extend {
+      bool is_empty() const {
+        return $self->empty();
+      }
+      T pop() throw (std::out_of_range) {
+        if (self->size() == 0)
+          throw std::out_of_range("pop from empty vector");
+        T x = self->back();
+        self->pop_back();
+        return x;
+      }
+      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);
+    void clear();
+    %rename(push) push_back;
+    void push_back(const value_type& x);
+    %extend {
+      bool is_empty() const {
+        return $self->empty();
+      }
+      bool pop() throw (std::out_of_range) {
+        if (self->size() == 0)
+          throw std::out_of_range("pop from empty vector");
+        bool x = self->back();
+        self->pop_back();
+        return x;
+      }
+      bool 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");
+      }
+    }
+  };
+}
+
+%define specialize_std_vector(T)
+#warning "specialize_std_vector - specialization for type T no longer needed"
+%enddef
+
+
diff --git a/share/swig/2.0.11/ruby/stl.i b/share/swig/3.0.12/php5/stl.i
index 9d2e91e..9d2e91e 100644
--- a/share/swig/2.0.11/ruby/stl.i
+++ b/share/swig/3.0.12/php5/stl.i
diff --git a/share/swig/3.0.12/php5/typemaps.i b/share/swig/3.0.12/php5/typemaps.i
new file mode 100644
index 0000000..faae0a6
--- /dev/null
+++ b/share/swig/3.0.12/php5/typemaps.i
@@ -0,0 +1,322 @@
+/* -----------------------------------------------------------------------------
+ * typemaps.i.
+ *
+ * SWIG Typemap library for PHP.
+ *
+ * This library provides standard typemaps for modifying SWIG's behavior.
+ * With enough entries in this file, I hope that very few people actually
+ * ever need to write a typemap.
+ *
+ * Define macros to define the following typemaps:
+ *
+ * TYPE *INPUT.   Argument is passed in as native variable by value.
+ * TYPE *OUTPUT.  Argument is returned as an array from the function call.
+ * TYPE *INOUT.   Argument is passed in by value, and out as part of returned list
+ * TYPE *REFERENCE.  Argument is passed in as native variable with value
+ *                   semantics.  Variable value is changed with result.
+ *                   Use like this:
+ *                   int foo(int *REFERENCE);
+ *
+ *                   $a = 0;
+ *                   $rc = foo($a);
+ *
+ *                   Even though $a looks like it's passed by value,
+ *                   its value can be changed by foo().
+ * ----------------------------------------------------------------------------- */
+
+%define BOOL_TYPEMAP(TYPE)
+%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
+%{
+  convert_to_boolean_ex($input);
+  temp = Z_LVAL_PP($input) ? true : false;
+  $1 = &temp;
+%}
+%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
+%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
+%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
+{
+  zval *o;
+  MAKE_STD_ZVAL(o);
+  ZVAL_BOOL(o,temp$argnum);
+  t_output_helper( &$result, o TSRMLS_CC );
+}
+%typemap(in) TYPE *REFERENCE (TYPE lvalue), TYPE &REFERENCE (TYPE lvalue)
+%{
+  convert_to_boolean_ex($input);
+  lvalue = (*$input)->value.lval ? true : false;
+  $1 = &lvalue;
+%}
+%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
+%{
+  (*$arg)->value.lval = lvalue$argnum ? true : false;
+  (*$arg)->type = IS_BOOL;
+%}
+%enddef
+
+%define DOUBLE_TYPEMAP(TYPE)
+%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
+%{
+  convert_to_double_ex($input);
+  temp = (TYPE) Z_DVAL_PP($input);
+  $1 = &temp;
+%}
+%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
+%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
+%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
+{
+  zval *o;
+  MAKE_STD_ZVAL(o);
+  ZVAL_DOUBLE(o,temp$argnum);
+  t_output_helper( &$result, o TSRMLS_CC );
+}
+%typemap(in) TYPE *REFERENCE (TYPE dvalue), TYPE &REFERENCE (TYPE dvalue)
+%{
+  convert_to_double_ex($input);
+  dvalue = (TYPE) (*$input)->value.dval;
+  $1 = &dvalue;
+%}
+%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
+%{
+  $1->value.dval = (double)(lvalue$argnum);
+  $1->type = IS_DOUBLE;
+%}
+%enddef
+
+%define INT_TYPEMAP(TYPE)
+%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
+%{
+  convert_to_long_ex($input);
+  temp = (TYPE) Z_LVAL_PP($input);
+  $1 = &temp;
+%}
+%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
+%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
+%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
+{
+  zval *o;
+  MAKE_STD_ZVAL(o);
+  ZVAL_LONG(o,temp$argnum);
+  t_output_helper( &$result, o TSRMLS_CC );
+}
+%typemap(in) TYPE *REFERENCE (TYPE lvalue), TYPE &REFERENCE (TYPE lvalue)
+%{
+  convert_to_long_ex($input);
+  lvalue = (TYPE) (*$input)->value.lval;
+  $1 = &lvalue;
+%}
+%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
+%{
+  (*$arg)->value.lval = (long)(lvalue$argnum);
+  (*$arg)->type = IS_LONG;
+%}
+%enddef
+
+BOOL_TYPEMAP(bool);
+
+DOUBLE_TYPEMAP(float);
+DOUBLE_TYPEMAP(double);
+
+INT_TYPEMAP(int);
+INT_TYPEMAP(short);
+INT_TYPEMAP(long);
+INT_TYPEMAP(unsigned int);
+INT_TYPEMAP(unsigned short);
+INT_TYPEMAP(unsigned long);
+INT_TYPEMAP(unsigned char);
+INT_TYPEMAP(signed char);
+
+INT_TYPEMAP(long long);
+%typemap(argout,fragment="t_output_helper") long long *OUTPUT
+{
+  zval *o;
+  MAKE_STD_ZVAL(o);
+  if ((long long)LONG_MIN <= temp$argnum && temp$argnum <= (long long)LONG_MAX) {
+    ZVAL_LONG(o, temp$argnum);
+  } else {
+    char temp[256];
+    sprintf(temp, "%lld", (long long)temp$argnum);
+    ZVAL_STRING(o, temp, 1);
+  }
+  t_output_helper( &$result, o TSRMLS_CC );
+}
+%typemap(in) TYPE *REFERENCE (long long lvalue)
+%{
+  CONVERT_LONG_LONG_IN(lvalue, long long, $input)
+  $1 = &lvalue;
+%}
+%typemap(argout) long long *REFERENCE
+%{
+  if ((long long)LONG_MIN <= lvalue$argnum && lvalue$argnum <= (long long)LONG_MAX) {
+    (*$arg)->value.lval = (long)(lvalue$argnum);
+    (*$arg)->type = IS_LONG;
+  } else {
+    char temp[256];
+    sprintf(temp, "%lld", (long long)lvalue$argnum);
+    ZVAL_STRING((*$arg), temp, 1);
+  }
+%}
+%typemap(argout) long long &OUTPUT
+%{
+  if ((long long)LONG_MIN <= *arg$argnum && *arg$argnum <= (long long)LONG_MAX) {
+    ($result)->value.lval = (long)(*arg$argnum);
+    ($result)->type = IS_LONG;
+  } else {
+    char temp[256];
+    sprintf(temp, "%lld", (long long)(*arg$argnum));
+    ZVAL_STRING($result, temp, 1);
+  }
+%}
+INT_TYPEMAP(unsigned long long);
+%typemap(argout,fragment="t_output_helper") unsigned long long *OUTPUT
+{
+  zval *o;
+  MAKE_STD_ZVAL(o);
+  if (temp$argnum <= (unsigned long long)LONG_MAX) {
+    ZVAL_LONG(o, temp$argnum);
+  } else {
+    char temp[256];
+    sprintf(temp, "%llu", (unsigned long long)temp$argnum);
+    ZVAL_STRING(o, temp, 1);
+  }
+  t_output_helper( &$result, o TSRMLS_CC );
+}
+%typemap(in) TYPE *REFERENCE (unsigned long long lvalue)
+%{
+  CONVERT_UNSIGNED_LONG_LONG_IN(lvalue, unsigned long long, $input)
+  $1 = &lvalue;
+%}
+%typemap(argout) unsigned long long *REFERENCE
+%{
+  if (lvalue$argnum <= (unsigned long long)LONG_MAX) {
+    (*$arg)->value.lval = (long)(lvalue$argnum);
+    (*$arg)->type = IS_LONG;
+  } else {
+    char temp[256];
+    sprintf(temp, "%llu", (unsigned long long)lvalue$argnum);
+    ZVAL_STRING((*$arg), temp, 1);
+  }
+%}
+%typemap(argout) unsigned long long &OUTPUT
+%{
+  if (*arg$argnum <= (unsigned long long)LONG_MAX) {
+    ($result)->value.lval = (long)(*arg$argnum);
+    ($result)->type = IS_LONG;
+  } else {
+    char temp[256];
+    sprintf(temp, "%llu", (unsigned long long)(*arg$argnum));
+    ZVAL_STRING($result, temp, 1);
+  }
+%}
+
+%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) 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 char *INOUT = unsigned char *INPUT;
+%typemap(in) unsigned long long *INOUT = unsigned long long *INPUT;
+%typemap(in) signed char *INOUT = signed 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) short &INOUT = short *INPUT;
+%typemap(in) long &INOUT = long *INPUT;
+%typemap(in) long long &INOUT = long long *INPUT;
+%typemap(in) long long &INPUT = 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 char &INOUT = unsigned char *INPUT;
+%typemap(in) unsigned long long &INOUT = unsigned long long *INPUT;
+%typemap(in) unsigned long long &INPUT = unsigned long long *INPUT;
+%typemap(in) signed char &INOUT = signed char *INPUT;
+
+%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) short *INOUT = short *OUTPUT;
+%typemap(argout) long *INOUT= long *OUTPUT;
+%typemap(argout) long long *INOUT= long long *OUTPUT;
+%typemap(argout) unsigned short *INOUT= unsigned short *OUTPUT;
+%typemap(argout) unsigned long *INOUT = unsigned long *OUTPUT;
+%typemap(argout) unsigned char *INOUT = unsigned char *OUTPUT;
+%typemap(argout) unsigned long long *INOUT = unsigned long long *OUTPUT;
+%typemap(argout) signed char *INOUT = signed 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) short &INOUT = short *OUTPUT;
+%typemap(argout) long &INOUT= long *OUTPUT;
+%typemap(argout) long long &INOUT= long long *OUTPUT;
+%typemap(argout) unsigned short &INOUT= unsigned short *OUTPUT;
+%typemap(argout) unsigned long &INOUT = unsigned long *OUTPUT;
+%typemap(argout) unsigned char &INOUT = unsigned char *OUTPUT;
+%typemap(argout) unsigned long long &INOUT = unsigned long long *OUTPUT;
+%typemap(argout) signed char &INOUT = signed char *OUTPUT;
+
+%typemap(in) char INPUT[ANY] ( char temp[$1_dim0] )
+%{
+  convert_to_string_ex($input);
+  strncpy(temp,Z_STRVAL_PP($input),$1_dim0);
+  $1 = temp;
+%}
+%typemap(in,numinputs=0) char OUTPUT[ANY] ( char temp[$1_dim0] )
+  "$1 = temp;";
+%typemap(argout,fragment="t_output_helper") char OUTPUT[ANY]
+{
+  zval *o;
+  MAKE_STD_ZVAL(o);
+  ZVAL_STRINGL(o,temp$argnum,$1_dim0);
+  t_output_helper( &$result, o TSRMLS_CC );
+}
+
+%typemap(in,numinputs=0) void **OUTPUT (int force),
+                         void *&OUTPUT (int force)
+%{
+  /* If they pass NULL by reference, make it into a void*
+     This bit should go in arginit if arginit support init-ing scripting args */
+  if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0) {
+    /* So... we didn't get a ref or ptr, but we'll accept NULL by reference */
+    if (!((*$input)->type==IS_NULL && PZVAL_IS_REF(*$input))) {
+      /* wasn't a pre/ref/thing, OR anything like an int thing */
+      SWIG_PHP_Error(E_ERROR, "Type error in argument $arg of $symname.");
+    }
+  }
+  force=0;
+  if (arg1==NULL) {
+#ifdef __cplusplus
+    ptr=new $*1_ltype();
+#else
+    ptr=($*1_ltype) calloc(1,sizeof($*1_ltype));
+#endif
+    $1=&ptr;
+    /* have to passback arg$arg too */
+    force=1;
+  }
+%}
+
+%typemap(argout) void **OUTPUT,
+                 void *&OUTPUT
+%{
+  if (force$argnum) {  /* pass back arg$argnum through params ($arg) if we can */
+    if (!PZVAL_IS_REF(*$arg)) {
+      SWIG_PHP_Error(E_WARNING, "Parameter $argnum of $symname wasn't passed by reference");
+    } else {
+      SWIG_SetPointerZval(*$arg, (void *) ptr$argnum, $*1_descriptor, 1);
+    }
+  }
+%}
diff --git a/share/swig/3.0.12/php5/utils.i b/share/swig/3.0.12/php5/utils.i
new file mode 100644
index 0000000..408a3b3
--- /dev/null
+++ b/share/swig/3.0.12/php5/utils.i
@@ -0,0 +1,114 @@
+
+%define CONVERT_BOOL_IN(lvar,t,invar)
+  convert_to_boolean_ex(invar);
+  lvar = (t) Z_LVAL_PP(invar);
+%enddef
+
+%define CONVERT_INT_IN(lvar,t,invar)
+  convert_to_long_ex(invar);
+  lvar = (t) Z_LVAL_PP(invar);
+%enddef
+
+%define CONVERT_LONG_LONG_IN(lvar,t,invar)
+  switch ((*(invar))->type) {
+      case IS_DOUBLE:
+          lvar = (t) (*(invar))->value.dval;
+          break;
+      case IS_STRING: {
+          char * endptr;
+          errno = 0;
+          lvar = (t) strtoll((*(invar))->value.str.val, &endptr, 10);
+          if (*endptr && !errno) break;
+          /* FALL THRU */
+      }
+      default:
+          convert_to_long_ex(invar);
+          lvar = (t) (*(invar))->value.lval;
+  }
+%enddef
+
+%define CONVERT_UNSIGNED_LONG_LONG_IN(lvar,t,invar)
+  switch ((*(invar))->type) {
+      case IS_DOUBLE:
+          lvar = (t) (*(invar))->value.dval;
+          break;
+      case IS_STRING: {
+          char * endptr;
+          errno = 0;
+          lvar = (t) strtoull((*(invar))->value.str.val, &endptr, 10);
+          if (*endptr && !errno) break;
+          /* FALL THRU */
+      }
+      default:
+          convert_to_long_ex(invar);
+          lvar = (t) (*(invar))->value.lval;
+  }
+%enddef
+
+%define CONVERT_INT_OUT(lvar,invar)
+  lvar = (t) Z_LVAL_PP(invar);
+%enddef
+
+%define CONVERT_FLOAT_IN(lvar,t,invar)
+  convert_to_double_ex(invar);
+  lvar = (t) Z_DVAL_PP(invar);
+%enddef
+
+%define CONVERT_CHAR_IN(lvar,t,invar)
+  convert_to_string_ex(invar);
+  lvar = (t) *Z_STRVAL_PP(invar);
+%enddef
+
+%define CONVERT_STRING_IN(lvar,t,invar)
+  if ((*invar)->type==IS_NULL) {
+    lvar = (t) 0;
+  } else {
+    convert_to_string_ex(invar);
+    lvar = (t) Z_STRVAL_PP(invar);
+  }
+%enddef
+
+%define %pass_by_val( TYPE, CONVERT_IN )
+%typemap(in) TYPE
+%{
+  CONVERT_IN($1,$1_ltype,$input);
+%}
+%typemap(in) const TYPE & ($*1_ltype temp)
+%{
+  CONVERT_IN(temp,$*1_ltype,$input);
+  $1 = &temp;
+%}
+%typemap(directorout) TYPE
+%{
+  CONVERT_IN($result,$1_ltype,&$input);
+%}
+%typemap(directorout) const TYPE & ($*1_ltype temp)
+%{
+  CONVERT_IN(temp,$*1_ltype,&$input);
+  $result = &temp;
+%}
+%enddef
+
+%fragment("t_output_helper","header") %{
+static void
+t_output_helper(zval **target, zval *o TSRMLS_DC) {
+  zval *tmp;
+  if ( (*target)->type == IS_ARRAY ) {
+    /* it's already an array, just append */
+    add_next_index_zval( *target, o );
+    return;
+  }
+  if ( (*target)->type == IS_NULL ) {
+    REPLACE_ZVAL_VALUE(target,o,1);
+    FREE_ZVAL(o);
+    return;
+  }
+  ALLOC_INIT_ZVAL(tmp);
+  *tmp = **target;
+  zval_copy_ctor(tmp);
+  array_init(*target);
+  add_next_index_zval( *target, tmp);
+  add_next_index_zval( *target, o);
+
+}
+%}
diff --git a/share/swig/3.0.12/pike/pike.swg b/share/swig/3.0.12/pike/pike.swg
new file mode 100644
index 0000000..95cc208
--- /dev/null
+++ b/share/swig/3.0.12/pike/pike.swg
@@ -0,0 +1,324 @@
+/* -----------------------------------------------------------------------------
+ * pike.swg
+ *
+ * Pike configuration module.
+ * ----------------------------------------------------------------------------- */
+
+%insert(runtime) "swigrun.swg";            // Common C API type-checking code
+%insert(runtime) "pikerun.swg";         // Pike run-time code
+
+%insert(runtime) %{
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <pike/global.h>
+#include <pike/module.h>
+#include <pike/interpret.h>
+#ifdef __cplusplus
+}
+#endif
+%}
+
+/* -----------------------------------------------------------------------------
+ *                          standard typemaps
+ * ----------------------------------------------------------------------------- */
+
+/* --- Input arguments --- */
+
+/* Primitive datatypes. */
+
+%typemap(in, pikedesc="tInt")
+    int, unsigned int, short, unsigned short,
+    long, unsigned long, char, signed char, unsigned char,
+    bool, enum SWIGTYPE, long long, unsigned long long
+{
+    if ($input.type != T_INT)
+        Pike_error("Bad argument: Expected an integer.\n");
+    $1 = ($1_ltype) $input.u.integer;
+}
+
+%typemap(in, pikedesc="tFloat") float, double {
+    if ($input.type != T_FLOAT)
+        Pike_error("Bad argument: Expected a float.\n");
+    $1 = ($1_ltype) $input.u.float_number;
+}
+
+%typemap(in, pikedesc="tStr") char *, char [ANY] {
+    if ($input.type != T_STRING)
+        Pike_error("Bad argument: Expected a string.\n");
+    $1 = ($1_ltype) STR0($input.u.string);
+}
+
+/* Pointers, references and arrays */
+
+%typemap(in) SWIGTYPE *,
+             SWIGTYPE &,
+             SWIGTYPE &&,
+             SWIGTYPE []
+	"SWIG_ConvertPtr($input.u.object, (void **) &$1, $1_descriptor, 1);"
+	
+/* Void pointer.  Accepts any kind of pointer */
+%typemap(in) void * "/* FIXME */";
+
+/* Object passed by value. Convert to a pointer */
+%typemap(in) SWIGTYPE ($&1_ltype argp) "/* FIXME */";
+
+/* Pointer to a class member */
+%typemap(in) SWIGTYPE (CLASS::*) "/* FIXME */";
+
+/* Const primitive references.  Passed by value */
+
+%typemap(in, pikedesc="tInt") const int & (int temp),
+	     const short & (short temp),
+             const long  & (long temp),
+             const unsigned int & (unsigned int temp),
+             const unsigned short & (unsigned short temp),
+             const unsigned long & (unsigned long temp),
+	     const char & (char temp),
+             const signed char & (signed char temp),
+             const unsigned char & (unsigned char temp),
+             const bool & (bool temp),
+	     const long long & ($*1_ltype temp),
+	     const unsigned long long & ($*1_ltype temp),
+             const enum SWIGTYPE & ($*1_ltype temp),
+             const enum SWIGTYPE && ($*1_ltype temp)
+{
+  if ($input.type != T_INT)
+    Pike_error("Bad argument: Expected an integer.\n");
+    temp = ($*1_ltype) $input.u.integer;
+    $1 = &temp;
+}
+
+%typemap(in, pikedesc="tFloat") const float & (float temp),
+	     const double & (double temp)
+{
+  if ($input.type != T_FLOAT)
+    Pike_error("Bad argument: Expected a float.\n");
+    temp = ($*1_ltype) $input.u.float_number;
+    $1 = &temp;
+}
+
+/* -----------------------------------------------------------------------------
+ * Output Typemaps
+ * ----------------------------------------------------------------------------- */
+%typemap(out, pikedesc="tInt")
+    int, unsigned int,
+    short, unsigned short,
+    long, unsigned long,
+    char, signed char, unsigned char, 
+    bool, enum SWIGTYPE
+	"push_int($1);";
+
+%typemap(out, pikedesc="tInt") long long	"push_int64($1);";
+%typemap(out, pikedesc="tInt") unsigned long long	"push_int64($1);";
+%typemap(out, pikedesc="tFloat") float, double	"push_float($1);";
+%typemap(out, pikedesc="tStr") char *		"push_text($1);";
+
+/* Pointers, references, and arrays */
+%typemap(out, pikedesc="tObj") SWIGTYPE*, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] "push_object(SWIG_NewPointerObj((void *) $1, $1_descriptor, $owner));";
+
+/* Void return value; don't push anything */
+%typemap(out, pikedesc="tVoid") void		"";
+
+/* Dynamic casts */
+
+%typemap(out) SWIGTYPE *DYNAMIC, SWIGTYPE &DYNAMIC "/* FIXME */";
+
+/* Member pointer */
+%typemap(out) SWIGTYPE (CLASS::*) "/* FIXME */";
+
+/* Special typemap for character array return values */
+%typemap(out, pikedesc="tStr") char [ANY], const char [ANY] "push_text($1);";
+
+/* Primitive types--return by value */
+%typemap(out, pikedesc="tObj") SWIGTYPE 
+#ifdef __cplusplus
+{
+  $&1_ltype resultptr;
+  resultptr = new $1_ltype((const $1_ltype &) $1);
+  push_object(SWIG_NewPointerObj((void *) resultptr, $&1_descriptor, 1));
+}
+#else
+{
+  $&1_ltype resultptr;
+  resultptr = ($&1_ltype) malloc(sizeof($1_type));
+  memmove(resultptr, &$1, sizeof($1_type));
+  push_object(SWIG_NewPointerObj((void *) resultptr, $&1_descriptor, 1));
+}
+#endif
+
+/* References to primitive types.  Return by value */
+
+%typemap(out, pikedesc="tInt") const int &, const unsigned int &,
+              const short &, const unsigned short &,
+              const long &, const unsigned long &,
+              const char &, const signed char &, const unsigned char &,
+              const bool &,
+	      const long long &, const unsigned long long &,
+              const enum SWIGTYPE & ($*1_ltype temp),
+              const enum SWIGTYPE && ($*1_ltype temp)
+      "push_int(*($1));";
+
+%typemap(out, pikedesc="tFloat") const float &, const double &  "push_float(*($1));";
+
+/************************ Constant Typemaps *****************************/
+
+%typemap(constant)
+    int, unsigned int,
+    short, unsigned short,
+    long, unsigned long,
+    signed char, unsigned char, 
+    bool, enum SWIGTYPE,
+    long long, unsigned long long
+    	"add_integer_constant(\"$symname\", $1, 0);";
+
+%typemap(constant) char
+	"add_integer_constant(\"$symname\", '$1', 0);";
+
+%typemap(constant) long long, unsigned long long
+	"add_integer_constant(\"$symname\", $1, 0);";
+
+%typemap(constant) float, double
+	"add_float_constant(\"$symname\", $1, 0);";
+
+%typemap(constant) char *
+	"add_string_constant(\"$symname\", \"$1\", 0);";
+
+/* ------------------------------------------------------------
+ * String & length
+ * ------------------------------------------------------------ */
+
+%typemap(in) (char *STRING, int LENGTH), (char *STRING, size_t LENGTH) {
+    if ($input.type != T_STRING)
+        Pike_error("Bad argument: Expected a string.\n");
+    $1 = ($1_ltype) STR0($input.u.string);
+    $2 = ($2_ltype) $input.u.string->length;
+}
+
+/* ------------------------------------------------------------
+ * ANSI C typemaps
+ * ------------------------------------------------------------ */
+
+%typemap(in, pikedesc="tInt") size_t {
+    if ($input.type != T_INT)
+        Pike_error("Bad argument: Expected an integer.\n");
+    $1 = ($1_ltype) $input.u.integer;
+}
+
+%typemap(out)      size_t = long;
+
+/* ------------------------------------------------------------
+ * Typechecking rules
+ * ------------------------------------------------------------ */
+
+%typecheck(SWIG_TYPECHECK_INTEGER)
+	 int, short, long,
+ 	 unsigned int, unsigned short, unsigned long,
+	 signed char, unsigned char,
+	 long long, unsigned long long,
+	 const int &, const short &, const long &,
+ 	 const unsigned int &, const unsigned short &, const unsigned long &,
+	 const long long &, const unsigned long long &,
+	 enum SWIGTYPE, enum SWIGTYPE &, SWIGTYPE &&,
+         bool, const bool & 
+{
+  $1 = ($input.type == T_INT) ? 1 : 0;
+}
+
+%typecheck(SWIG_TYPECHECK_DOUBLE)
+	float, double,
+	const float &, const double &
+{
+  $1 = (($input.type == T_FLOAT) || ($input.type == T_INT)) ? 1 : 0;
+}
+
+%typecheck(SWIG_TYPECHECK_CHAR) char {
+  $1 = ($input.type == T_INT) ? 1 : 0;
+}
+
+%typecheck(SWIG_TYPECHECK_STRING) char * {
+  $1 = ($input.type == T_STRING) ? 1 : 0;
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] {
+  void *ptr;
+  if (SWIG_ConvertPtr($input.u.object, (void **) &ptr, $1_descriptor, 0) == -1) {
+    $1 = 0;
+  } else {
+    $1 = 1;
+  }
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE {
+  void *ptr;
+  if (SWIG_ConvertPtr($input.u.object, (void **) &ptr, $&1_descriptor, 0) == -1) {
+    $1 = 0;
+  } else {
+    $1 = 1;
+  }
+}
+
+%typecheck(SWIG_TYPECHECK_VOIDPTR) void * {
+  void *ptr;
+  if (SWIG_ConvertPtr($input.u.object, (void **) &ptr, 0, 0) == -1) {
+    $1 = 0;
+  } else {
+    $1 = 1;
+  }
+}
+
+/* Array reference typemaps */
+%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) }
+
+/* const pointers */
+%apply SWIGTYPE * { SWIGTYPE *const }
+
+/* ------------------------------------------------------------
+ * Overloaded operator support
+ * ------------------------------------------------------------ */
+
+#ifdef __cplusplus
+%rename("`+")      *::operator+;
+%rename("`-")      *::operator-;
+%rename("`*")      *::operator*;
+%rename("`/")      *::operator/;
+%rename("`%")      *::operator%;
+%rename("`<<")     *::operator<<;
+%rename("`>>")     *::operator>>;
+%rename("`&")      *::operator&;
+%rename("`|")      *::operator|;
+%rename("`^")      *::operator^;
+%rename("`~")      *::operator~;
+%rename("`<")      *::operator<;
+%rename("`>")      *::operator>;
+%rename("`==")     *::operator==;
+
+/* Special cases */
+%rename("`()")     *::operator();
+
+#endif
+
+/* ------------------------------------------------------------
+ * The start of the Pike initialization function
+ * ------------------------------------------------------------ */
+
+%init "swiginit.swg"
+
+%init %{
+#ifdef __cplusplus
+extern "C"
+#endif
+PIKE_MODULE_EXIT {}
+
+#ifdef __cplusplus
+extern "C"
+#endif
+PIKE_MODULE_INIT
+{
+    struct program *pr;
+    SWIG_InitializeModule(0);
+%}
+
+/* pike keywords */
+%include <pikekw.swg>
diff --git a/share/swig/2.0.11/pike/pikekw.swg b/share/swig/3.0.12/pike/pikekw.swg
index 844b1f1..844b1f1 100644
--- a/share/swig/2.0.11/pike/pikekw.swg
+++ b/share/swig/3.0.12/pike/pikekw.swg
diff --git a/share/swig/2.0.11/pike/pikerun.swg b/share/swig/3.0.12/pike/pikerun.swg
index 6ec1143..6ec1143 100644
--- a/share/swig/2.0.11/pike/pikerun.swg
+++ b/share/swig/3.0.12/pike/pikerun.swg
diff --git a/share/swig/2.0.11/pike/std_string.i b/share/swig/3.0.12/pike/std_string.i
index b32b3c1..b32b3c1 100644
--- a/share/swig/2.0.11/pike/std_string.i
+++ b/share/swig/3.0.12/pike/std_string.i
diff --git a/share/swig/3.0.12/pointer.i b/share/swig/3.0.12/pointer.i
new file mode 100644
index 0000000..ea8e535
--- /dev/null
+++ b/share/swig/3.0.12/pointer.i
@@ -0,0 +1,11 @@
+/* -----------------------------------------------------------------------------
+ * pointer.i
+ * ----------------------------------------------------------------------------- */
+
+
+%echo "pointer.i is deprecated.  Use cpointer.i instead."
+%echo "See http://www.swig.org/Doc3.0/Library.html"
+
+
+
+
diff --git a/share/swig/2.0.11/python/argcargv.i b/share/swig/3.0.12/python/argcargv.i
index 717fe73..717fe73 100644
--- a/share/swig/2.0.11/python/argcargv.i
+++ b/share/swig/3.0.12/python/argcargv.i
diff --git a/share/swig/2.0.11/python/attribute.i b/share/swig/3.0.12/python/attribute.i
index 779716c..779716c 100644
--- a/share/swig/2.0.11/python/attribute.i
+++ b/share/swig/3.0.12/python/attribute.i
diff --git a/share/swig/3.0.12/python/boost_shared_ptr.i b/share/swig/3.0.12/python/boost_shared_ptr.i
new file mode 100644
index 0000000..40a1ae1
--- /dev/null
+++ b/share/swig/3.0.12/python/boost_shared_ptr.i
@@ -0,0 +1,324 @@
+%include <shared_ptr.i>
+
+// Set SHARED_PTR_DISOWN to $disown if required, for example
+// #define SHARED_PTR_DISOWN $disown
+#if !defined(SHARED_PTR_DISOWN)
+#define SHARED_PTR_DISOWN 0
+#endif
+
+%fragment("SWIG_null_deleter_python", "header", fragment="SWIG_null_deleter") {
+%#define SWIG_NO_NULL_DELETER_SWIG_BUILTIN_INIT
+}
+
+// Language specific macro implementing all the customisations for handling the smart pointer
+%define SWIG_SHARED_PTR_TYPEMAPS(CONST, TYPE...)
+
+// %naturalvar is as documented for member variables
+%naturalvar TYPE;
+%naturalvar SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
+
+// destructor wrapper customisation
+%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) CONST TYPE (void *argp, int res = 0) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (!argp) {
+    %argument_nullref("$type", $symname, $argnum);
+  } else {
+    $1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
+    if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+  }
+}
+%typemap(out) CONST TYPE {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) CONST TYPE {
+  void *argp = 0;
+  int newmem = 0;
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  if (!argp) {
+    %variable_nullref("$type", "$name");
+  } else {
+    $1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
+    if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+  }
+}
+%typemap(varout) CONST TYPE {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+// plain pointer
+// Note: $disown not implemented by default as it will lead to a memory leak of the shared_ptr instance
+%typemap(in) CONST TYPE * (void  *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SHARED_PTR_DISOWN | %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast(tempshared.get(), $1_ltype);
+  } else {
+    smartarg = %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
+  }
+}
+
+%typemap(out, fragment="SWIG_null_deleter_python") CONST TYPE * {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), $owner | SWIG_POINTER_OWN));
+}
+
+%typemap(varin) CONST TYPE * {
+  void *argp = 0;
+  int newmem = 0;
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0;
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast(tempshared.get(), $1_ltype);
+  } else {
+    smartarg = %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
+  }
+}
+%typemap(varout, fragment="SWIG_null_deleter_python") CONST TYPE * {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_0) : 0;
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+// plain reference
+%typemap(in) CONST TYPE & (void  *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (!argp) { %argument_nullref("$type", $symname, $argnum); }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast(tempshared.get(), $1_ltype);
+  } else {
+    $1 = %const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
+  }
+}
+%typemap(out, fragment="SWIG_null_deleter_python") CONST TYPE & {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner);
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) CONST TYPE & {
+  void *argp = 0;
+  int newmem = 0;
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
+  if (!argp) {
+    %variable_nullref("$type", "$name");
+  }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = *%const_cast(tempshared.get(), $1_ltype);
+  } else {
+    $1 = *%const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
+  }
+}
+%typemap(varout, fragment="SWIG_null_deleter_python") CONST TYPE & {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(&$1 SWIG_NO_NULL_DELETER_0);
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+// plain pointer by reference
+// Note: $disown not implemented by default as it will lead to a memory leak of the shared_ptr instance
+%typemap(in) TYPE *CONST& (void  *argp = 0, int res = 0, $*1_ltype temp = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SHARED_PTR_DISOWN | %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    temp = %const_cast(tempshared.get(), $*1_ltype);
+  } else {
+    temp = %const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $*1_ltype);
+  }
+  $1 = &temp;
+}
+%typemap(out, fragment="SWIG_null_deleter_python") TYPE *CONST& {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1 SWIG_NO_NULL_DELETER_$owner);
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) TYPE *CONST& %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) TYPE *CONST& %{
+#error "varout typemap not implemented"
+%}
+
+// shared_ptr by value
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > (void *argp, int res = 0) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (argp) $1 = *(%reinterpret_cast(argp, $&ltype));
+  if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $&ltype);
+}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
+  int newmem = 0;
+  void *argp = 0;
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  $1 = argp ? *(%reinterpret_cast(argp, $&ltype)) : SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE >();
+  if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $&ltype);
+}
+%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+// shared_ptr by reference
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & (void *argp, int res = 0, $*1_ltype tempshared) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
+    delete %reinterpret_cast(argp, $ltype);
+    $1 = &tempshared;
+  } else {
+    $1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
+  }
+}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
+#error "varout typemap not implemented"
+%}
+
+// shared_ptr by pointer
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * (void *argp, int res = 0, $*1_ltype tempshared) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
+    delete %reinterpret_cast(argp, $ltype);
+    $1 = &tempshared;
+  } else {
+    $1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
+  }
+}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 && *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+  if ($owner) delete $1;
+}
+
+%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
+#error "varout typemap not implemented"
+%}
+
+// shared_ptr by pointer reference
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& (void *argp, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, $*1_ltype temp = 0) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (argp) tempshared = *%reinterpret_cast(argp, $*ltype);
+  if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $*ltype);
+  temp = &tempshared;
+  $1 = &temp;
+}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 && **$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(**$1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
+#error "varout typemap not implemented"
+%}
+
+// Typecheck typemaps
+// Note: SWIG_ConvertPtr with void ** parameter set to 0 instead of using SWIG_ConvertPtrAndOwn, so that the casting 
+// function is not called thereby avoiding a possible smart pointer copy constructor call when casting up the inheritance chain.
+%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1) 
+                      TYPE CONST,
+                      TYPE CONST &,
+                      TYPE CONST *,
+                      TYPE *CONST&,
+                      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 > *& {
+  int res = SWIG_ConvertPtr($input, 0, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), 0);
+  $1 = SWIG_CheckState(res);
+}
+
+
+// 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"
+%}
+
+
+%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
+
+
+%enddef
+
diff --git a/share/swig/3.0.12/python/builtin.swg b/share/swig/3.0.12/python/builtin.swg
new file mode 100644
index 0000000..4fd1947
--- /dev/null
+++ b/share/swig/3.0.12/python/builtin.swg
@@ -0,0 +1,727 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGINTERN Py_hash_t
+SwigPyObject_hash(PyObject *obj) {
+  SwigPyObject *sobj = (SwigPyObject *)obj;
+  void *ptr = sobj->ptr;
+  return (Py_hash_t)ptr;
+}
+
+SWIGINTERN Py_hash_t
+SWIG_PyNumber_AsPyHash(PyObject *obj) {
+  Py_hash_t result = -1;
+#if PY_VERSION_HEX < 0x03020000
+#if PY_VERSION_HEX < 0x03000000
+  if (PyInt_Check(obj))
+    result = PyInt_AsLong(obj);
+  else
+#endif
+  if (PyLong_Check(obj))
+    result = PyLong_AsLong(obj);
+#else
+  if (PyNumber_Check(obj))
+    result = PyNumber_AsSsize_t(obj, NULL);
+#endif
+  else
+    PyErr_Format(PyExc_TypeError, "Wrong type for hash function");
+  return PyErr_Occurred() ? -1 : result;
+}
+
+SWIGINTERN int
+SwigPyBuiltin_BadInit(PyObject *self, PyObject *SWIGUNUSEDPARM(args), PyObject *SWIGUNUSEDPARM(kwds)) {
+  PyErr_Format(PyExc_TypeError, "Cannot create new instances of type '%.300s'", self->ob_type->tp_name);
+  return -1;
+}
+
+SWIGINTERN void
+SwigPyBuiltin_BadDealloc(PyObject *obj) {
+  SwigPyObject *sobj = (SwigPyObject *)obj;
+  if (sobj->own) {
+    PyErr_Format(PyExc_TypeError, "Swig detected a memory leak in type '%.300s': no callable destructor found.", obj->ob_type->tp_name);
+  }
+}
+
+typedef struct {
+  PyCFunction get;
+  PyCFunction set;
+} SwigPyGetSet;
+
+SWIGINTERN PyObject *
+SwigPyBuiltin_GetterClosure (PyObject *obj, void *closure) {
+  SwigPyGetSet *getset;
+  PyObject *tuple, *result;
+  if (!closure)
+    return SWIG_Py_Void();
+  getset = (SwigPyGetSet *)closure;
+  if (!getset->get)
+    return SWIG_Py_Void();
+  tuple = PyTuple_New(0);
+  assert(tuple);
+  result = (*getset->get)(obj, tuple);
+  Py_DECREF(tuple);
+  return result;
+}
+
+SWIGINTERN PyObject *
+SwigPyBuiltin_FunpackGetterClosure (PyObject *obj, void *closure) {
+  SwigPyGetSet *getset;
+  PyObject *result;
+  if (!closure)
+    return SWIG_Py_Void();
+  getset = (SwigPyGetSet *)closure;
+  if (!getset->get)
+    return SWIG_Py_Void();
+  result = (*getset->get)(obj, NULL);
+  return result;
+}
+
+SWIGINTERN int
+SwigPyBuiltin_SetterClosure (PyObject *obj, PyObject *val, void *closure) {
+  SwigPyGetSet *getset;
+  PyObject *tuple, *result;
+  if (!closure) {
+    PyErr_Format(PyExc_TypeError, "Missing getset closure");
+    return -1;
+  }
+  getset = (SwigPyGetSet *)closure;
+  if (!getset->set) {
+    PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
+    return -1;
+  }
+  tuple = PyTuple_New(1);
+  assert(tuple);
+  PyTuple_SET_ITEM(tuple, 0, val);
+  Py_XINCREF(val);
+  result = (*getset->set)(obj, tuple);
+  Py_DECREF(tuple);
+  Py_XDECREF(result);
+  return result ? 0 : -1;
+}
+
+SWIGINTERN int
+SwigPyBuiltin_FunpackSetterClosure (PyObject *obj, PyObject *val, void *closure) {
+  SwigPyGetSet *getset;
+  PyObject *result;
+  if (!closure) {
+    PyErr_Format(PyExc_TypeError, "Missing getset closure");
+    return -1;
+  }
+  getset = (SwigPyGetSet *)closure;
+  if (!getset->set) {
+    PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
+    return -1;
+  }
+  result = (*getset->set)(obj, val);
+  Py_XDECREF(result);
+  return result ? 0 : -1;
+}
+
+SWIGINTERN void
+SwigPyStaticVar_dealloc(PyDescrObject *descr) {
+  _PyObject_GC_UNTRACK(descr);
+  Py_XDECREF(PyDescr_TYPE(descr));
+  Py_XDECREF(PyDescr_NAME(descr));
+  PyObject_GC_Del(descr);
+}
+
+SWIGINTERN PyObject *
+SwigPyStaticVar_repr(PyGetSetDescrObject *descr) {
+#if PY_VERSION_HEX >= 0x03000000
+
+  return PyUnicode_FromFormat("<class attribute '%S' of type '%s'>", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
+#else
+  return PyString_FromFormat("<class attribute '%s' of type '%s'>", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
+#endif
+}
+
+SWIGINTERN int
+SwigPyStaticVar_traverse(PyObject *self, visitproc visit, void *arg) {
+  PyDescrObject *descr;
+  descr = (PyDescrObject *)self;
+  Py_VISIT((PyObject*) PyDescr_TYPE(descr));
+  return 0;
+}
+
+SWIGINTERN PyObject *
+SwigPyStaticVar_get(PyGetSetDescrObject *descr, PyObject *obj, PyObject *SWIGUNUSEDPARM(type)) {
+  if (descr->d_getset->get != NULL)
+    return descr->d_getset->get(obj, descr->d_getset->closure);
+#if PY_VERSION_HEX >= 0x03000000
+  PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not readable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
+#else
+  PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not readable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
+#endif
+  return NULL;
+}
+
+SWIGINTERN int
+SwigPyStaticVar_set(PyGetSetDescrObject *descr, PyObject *obj, PyObject *value) {
+  if (descr->d_getset->set != NULL)
+    return descr->d_getset->set(obj, value, descr->d_getset->closure);
+#if PY_VERSION_HEX >= 0x03000000
+  PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not writable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
+#else
+  PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not writable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
+#endif
+  return -1;
+}
+
+SWIGINTERN int
+SwigPyObjectType_setattro(PyObject *typeobject, PyObject *name, PyObject *value) {
+  PyObject *attribute;
+  PyTypeObject *type;
+  descrsetfunc local_set;
+
+  assert(PyType_Check(typeobject));
+  type = (PyTypeObject *)typeobject;
+  attribute = _PyType_Lookup(type, name);
+  if (attribute != NULL) {
+    /* Implement descriptor functionality, if any */
+    local_set = attribute->ob_type->tp_descr_set;
+    if (local_set != NULL)
+      return local_set(attribute, (PyObject *)type, value);
+#if PY_VERSION_HEX >= 0x03000000
+    PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400S'", type->tp_name, name);
+#else 
+    PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400s'", type->tp_name, PyString_AS_STRING(name));
+#endif
+  } else {
+#if PY_VERSION_HEX >= 0x03000000
+    PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400S'", type->tp_name, name);
+#else
+    PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400s'", type->tp_name, PyString_AS_STRING(name));
+#endif
+  }
+
+  return -1;
+}
+
+SWIGINTERN PyTypeObject*
+SwigPyStaticVar_Type(void) {
+  static PyTypeObject staticvar_type;
+  static int type_init = 0;
+  if (!type_init) {
+    const PyTypeObject tmp = {
+#if PY_VERSION_HEX >= 0x03000000
+      PyVarObject_HEAD_INIT(&PyType_Type, 0)
+#else
+      PyObject_HEAD_INIT(&PyType_Type)
+      0,                                        /* ob_size */
+#endif
+      "swig_static_var_getset_descriptor",      /* tp_name */
+      sizeof(PyGetSetDescrObject),              /* tp_basicsize */
+      0,                                        /* tp_itemsize */
+      (destructor)SwigPyStaticVar_dealloc,      /* tp_dealloc */
+      0,                                        /* tp_print */
+      0,                                        /* tp_getattr */
+      0,                                        /* tp_setattr */
+      0,                                        /* tp_compare */
+      (reprfunc)SwigPyStaticVar_repr,           /* tp_repr */
+      0,                                        /* tp_as_number */
+      0,                                        /* tp_as_sequence */
+      0,                                        /* tp_as_mapping */
+      0,                                        /* tp_hash */
+      0,                                        /* tp_call */
+      0,                                        /* tp_str */
+      PyObject_GenericGetAttr,                  /* tp_getattro */
+      0,                                        /* tp_setattro */
+      0,                                        /* tp_as_buffer */
+      Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
+      0,                                        /* tp_doc */
+      SwigPyStaticVar_traverse,                 /* tp_traverse */
+      0,                                        /* tp_clear */
+      0,                                        /* tp_richcompare */
+      0,                                        /* tp_weaklistoffset */
+      0,                                        /* tp_iter */
+      0,                                        /* tp_iternext */
+      0,                                        /* tp_methods */
+      0,                                        /* tp_members */
+      0,                                        /* tp_getset */
+      0,                                        /* tp_base */
+      0,                                        /* tp_dict */
+      (descrgetfunc)SwigPyStaticVar_get,        /* tp_descr_get */
+      (descrsetfunc)SwigPyStaticVar_set,        /* tp_descr_set */
+      0,                                        /* tp_dictoffset */
+      0,                                        /* tp_init */
+      0,                                        /* tp_alloc */
+      0,                                        /* tp_new */
+      0,                                        /* tp_free */
+      0,                                        /* tp_is_gc */
+      0,                                        /* tp_bases */
+      0,                                        /* tp_mro */
+      0,                                        /* tp_cache */
+      0,                                        /* tp_subclasses */
+      0,                                        /* tp_weaklist */
+#if PY_VERSION_HEX >= 0x02030000
+      0,                                        /* tp_del */
+#endif
+#if PY_VERSION_HEX >= 0x02060000
+      0,                                        /* tp_version_tag */
+#endif
+#if PY_VERSION_HEX >= 0x03040000
+      0,                                        /* tp_finalize */
+#endif
+#ifdef COUNT_ALLOCS
+      0,                                        /* tp_allocs */
+      0,                                        /* tp_frees */
+      0,                                        /* tp_maxalloc */
+#if PY_VERSION_HEX >= 0x02050000
+      0,                                        /* tp_prev */
+#endif
+      0                                         /* tp_next */
+#endif
+    };
+    staticvar_type = tmp;
+    type_init = 1;
+#if PY_VERSION_HEX < 0x02020000
+    staticvar_type.ob_type = &PyType_Type;
+#else
+    if (PyType_Ready(&staticvar_type) < 0)
+      return NULL;
+#endif
+  }
+  return &staticvar_type;
+}
+
+SWIGINTERN PyTypeObject*
+SwigPyObjectType(void) {
+  static char swigpyobjecttype_doc[] = "Metaclass for SWIG wrapped types";
+  static PyTypeObject swigpyobjecttype_type;
+  static int type_init = 0;
+  if (!type_init) {
+    const PyTypeObject tmp = {
+#if PY_VERSION_HEX >= 0x03000000
+      PyVarObject_HEAD_INIT(&PyType_Type, 0)
+#else
+      PyObject_HEAD_INIT(&PyType_Type)
+      0,                                        /* ob_size */
+#endif
+      "SwigPyObjectType",                       /* tp_name */
+      PyType_Type.tp_basicsize,                 /* tp_basicsize */
+      0,                                        /* tp_itemsize */
+      0,                                        /* tp_dealloc */
+      0,                                        /* tp_print */
+      0,                                        /* tp_getattr */
+      0,                                        /* tp_setattr */
+      0,                                        /* tp_compare */
+      0,                                        /* tp_repr */
+      0,                                        /* tp_as_number */
+      0,                                        /* tp_as_sequence */
+      0,                                        /* tp_as_mapping */
+      0,                                        /* tp_hash */
+      0,                                        /* tp_call */
+      0,                                        /* tp_str */
+      0,                                        /* tp_getattro */
+      SwigPyObjectType_setattro,                /* tp_setattro */
+      0,                                        /* tp_as_buffer */
+      Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
+      swigpyobjecttype_doc,                     /* tp_doc */
+      0,                                        /* tp_traverse */
+      0,                                        /* tp_clear */
+      0,                                        /* tp_richcompare */
+      0,                                        /* tp_weaklistoffset */
+      0,                                        /* tp_iter */
+      0,                                        /* tp_iternext */
+      0,                                        /* tp_methods */
+      0,                                        /* tp_members */
+      0,                                        /* tp_getset */
+      0,                                        /* tp_base */
+      0,                                        /* tp_dict */
+      0,                                        /* tp_descr_get */
+      0,                                        /* tp_descr_set */
+      0,                                        /* tp_dictoffset */
+      0,                                        /* tp_init */
+      0,                                        /* tp_alloc */
+      0,                                        /* tp_new */
+      0,                                        /* tp_free */
+      0,                                        /* tp_is_gc */
+      0,                                        /* tp_bases */
+      0,                                        /* tp_mro */
+      0,                                        /* tp_cache */
+      0,                                        /* tp_subclasses */
+      0,                                        /* tp_weaklist */
+#if PY_VERSION_HEX >= 0x02030000
+      0,                                        /* tp_del */
+#endif
+#if PY_VERSION_HEX >= 0x02060000
+      0,                                        /* tp_version_tag */
+#endif
+#if PY_VERSION_HEX >= 0x03040000
+      0,                                        /* tp_finalize */
+#endif
+#ifdef COUNT_ALLOCS
+      0,                                        /* tp_allocs */
+      0,                                        /* tp_frees */
+      0,                                        /* tp_maxalloc */
+#if PY_VERSION_HEX >= 0x02050000
+      0,                                        /* tp_prev */
+#endif
+      0                                         /* tp_next */
+#endif
+    };
+    swigpyobjecttype_type = tmp;
+    type_init = 1;
+    swigpyobjecttype_type.tp_base = &PyType_Type;
+#if PY_VERSION_HEX < 0x02020000
+    swigpyobjecttype_type.ob_type = &PyType_Type;
+#else
+    if (PyType_Ready(&swigpyobjecttype_type) < 0)
+      return NULL;
+#endif
+  }
+  return &swigpyobjecttype_type;
+}
+
+SWIGINTERN PyGetSetDescrObject *
+SwigPyStaticVar_new_getset(PyTypeObject *type, PyGetSetDef *getset) {
+
+  PyGetSetDescrObject *descr;
+  descr = (PyGetSetDescrObject *)PyType_GenericAlloc(SwigPyStaticVar_Type(), 0);
+  assert(descr);
+  Py_XINCREF(type);
+  PyDescr_TYPE(descr) = type;
+  PyDescr_NAME(descr) = PyString_InternFromString(getset->name);
+  descr->d_getset = getset;
+  if (PyDescr_NAME(descr) == NULL) {
+    Py_DECREF(descr);
+    descr = NULL;
+  }
+  return descr;
+}
+
+SWIGINTERN void
+SwigPyBuiltin_InitBases (PyTypeObject *type, PyTypeObject **bases) {
+  int base_count = 0;
+  PyTypeObject **b;
+  PyObject *tuple;
+  int i;
+
+  if (!bases[0]) {
+    bases[0] = SwigPyObject_type();
+    bases[1] = NULL;
+  }
+  type->tp_base = bases[0];
+  Py_INCREF((PyObject *)bases[0]);
+  for (b = bases; *b != NULL; ++b)
+    ++base_count;
+  tuple = PyTuple_New(base_count);
+  for (i = 0; i < base_count; ++i) {
+    PyTuple_SET_ITEM(tuple, i, (PyObject *)bases[i]);
+    Py_INCREF((PyObject *)bases[i]);
+  }
+  type->tp_bases = tuple;
+}
+
+SWIGINTERN PyObject *
+SwigPyBuiltin_ThisClosure (PyObject *self, void *SWIGUNUSEDPARM(closure)) {
+  PyObject *result;
+  result = (PyObject *)SWIG_Python_GetSwigThis(self);
+  Py_XINCREF(result);
+  return result;
+}
+
+SWIGINTERN void
+SwigPyBuiltin_SetMetaType (PyTypeObject *type, PyTypeObject *metatype)
+{
+#if PY_VERSION_HEX >= 0x03000000
+    type->ob_base.ob_base.ob_type = metatype;
+#else
+    type->ob_type = metatype;
+#endif
+}
+
+
+/* Start of callback function macros for use in PyTypeObject */
+
+typedef PyObject *(*SwigPyWrapperFunction)(PyObject *, PyObject *);
+
+#define SWIGPY_UNARYFUNC_CLOSURE(wrapper)		\
+SWIGINTERN PyObject *					\
+wrapper##_unaryfunc_closure(PyObject *a) {		\
+  return SwigPyBuiltin_unaryfunc_closure(wrapper, a);	\
+}
+SWIGINTERN PyObject *
+SwigPyBuiltin_unaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
+  return wrapper(a, NULL);
+}
+
+#define SWIGPY_DESTRUCTOR_CLOSURE(wrapper)			\
+SWIGINTERN void							\
+wrapper##_destructor_closure(PyObject *a) {			\
+    SwigPyBuiltin_destructor_closure(wrapper, #wrapper, a);	\
+}
+SWIGINTERN void
+SwigPyBuiltin_destructor_closure(SwigPyWrapperFunction wrapper, const char *wrappername, PyObject *a) {
+  SwigPyObject *sobj;
+  sobj = (SwigPyObject *)a;
+  Py_XDECREF(sobj->dict);
+  if (sobj->own) {
+    PyObject *o;
+    PyObject *val = 0, *type = 0, *tb = 0;
+    PyErr_Fetch(&val, &type, &tb);
+    o = wrapper(a, NULL);
+    if (!o) {
+      PyObject *deallocname = PyString_FromString(wrappername);
+      PyErr_WriteUnraisable(deallocname);
+      Py_DECREF(deallocname);
+    }
+    PyErr_Restore(val, type, tb);
+    Py_XDECREF(o);
+  }
+  if (PyType_IS_GC(a->ob_type)) {
+    PyObject_GC_Del(a);
+  } else {
+    PyObject_Del(a);
+  }
+}
+
+#define SWIGPY_INQUIRY_CLOSURE(wrapper)			\
+SWIGINTERN int						\
+wrapper##_inquiry_closure(PyObject *a) {		\
+  return SwigPyBuiltin_inquiry_closure(wrapper, a);	\
+}
+SWIGINTERN int
+SwigPyBuiltin_inquiry_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
+  PyObject *pyresult;
+  int result;
+  pyresult = wrapper(a, NULL);
+  result = pyresult && PyObject_IsTrue(pyresult) ? 1 : 0;
+  Py_XDECREF(pyresult);
+  return result;
+}
+
+#define SWIGPY_GETITERFUNC_CLOSURE(wrapper)		\
+SWIGINTERN PyObject *					\
+wrapper##_getiterfunc_closure(PyObject *a) {		\
+  return SwigPyBuiltin_getiterfunc_closure(wrapper, a);	\
+}
+SWIGINTERN PyObject *
+SwigPyBuiltin_getiterfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
+  return wrapper(a, NULL);
+}
+
+#define SWIGPY_BINARYFUNC_CLOSURE(wrapper)			\
+SWIGINTERN PyObject *						\
+wrapper##_binaryfunc_closure(PyObject *a, PyObject *b) {	\
+  return SwigPyBuiltin_binaryfunc_closure(wrapper, a, b);	\
+}
+SWIGINTERN PyObject *
+SwigPyBuiltin_binaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
+  PyObject *tuple, *result;
+  tuple = PyTuple_New(1);
+  assert(tuple);
+  PyTuple_SET_ITEM(tuple, 0, b);
+  Py_XINCREF(b);
+  result = wrapper(a, tuple);
+  Py_DECREF(tuple);
+  return result;
+}
+
+typedef ternaryfunc ternarycallfunc;
+
+#define SWIGPY_TERNARYFUNC_CLOSURE(wrapper)				\
+SWIGINTERN PyObject *							\
+wrapper##_ternaryfunc_closure(PyObject *a, PyObject *b, PyObject *c) {	\
+  return SwigPyBuiltin_ternaryfunc_closure(wrapper, a, b, c);		\
+}
+SWIGINTERN PyObject *
+SwigPyBuiltin_ternaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
+  PyObject *tuple, *result;
+  tuple = PyTuple_New(2);
+  assert(tuple);
+  PyTuple_SET_ITEM(tuple, 0, b);
+  PyTuple_SET_ITEM(tuple, 1, c);
+  Py_XINCREF(b);
+  Py_XINCREF(c);
+  result = wrapper(a, tuple);
+  Py_DECREF(tuple);
+  return result;
+}
+
+#define SWIGPY_TERNARYCALLFUNC_CLOSURE(wrapper)					\
+SWIGINTERN PyObject *								\
+wrapper##_ternarycallfunc_closure(PyObject *a, PyObject *b, PyObject *c) {	\
+  return SwigPyBuiltin_ternarycallfunc_closure(wrapper, a, b, c);		\
+}
+SWIGINTERN PyObject *
+SwigPyBuiltin_ternarycallfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
+  (void) c;
+  return wrapper(a, b);
+}
+
+#define SWIGPY_LENFUNC_CLOSURE(wrapper)			\
+SWIGINTERN Py_ssize_t					\
+wrapper##_lenfunc_closure(PyObject *a) {		\
+  return SwigPyBuiltin_lenfunc_closure(wrapper, a);	\
+}
+SWIGINTERN Py_ssize_t
+SwigPyBuiltin_lenfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
+  PyObject *resultobj;
+  Py_ssize_t result;
+  resultobj = wrapper(a, NULL);
+  result = PyNumber_AsSsize_t(resultobj, NULL);
+  Py_DECREF(resultobj);
+  return result;
+}
+
+#define SWIGPY_SSIZESSIZEARGFUNC_CLOSURE(wrapper)				\
+SWIGINTERN PyObject *								\
+wrapper##_ssizessizeargfunc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c) {	\
+  return SwigPyBuiltin_ssizessizeargfunc_closure(wrapper, a, b, c);		\
+}
+SWIGINTERN PyObject *
+SwigPyBuiltin_ssizessizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c) {
+  PyObject *tuple, *result;
+  tuple = PyTuple_New(2);
+  assert(tuple);
+  PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
+  PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
+  result = wrapper(a, tuple);
+  Py_DECREF(tuple);
+  return result;
+}
+
+#define SWIGPY_SSIZESSIZEOBJARGPROC_CLOSURE(wrapper)						\
+SWIGINTERN int											\
+wrapper##_ssizessizeobjargproc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) {	\
+  return SwigPyBuiltin_ssizessizeobjargproc_closure(wrapper, a, b, c, d);			\
+}
+SWIGINTERN int
+SwigPyBuiltin_ssizessizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) {
+  PyObject *tuple, *resultobj;
+  int result;
+  tuple = PyTuple_New(d ? 3 : 2);
+  assert(tuple);
+  PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
+  PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
+  if (d) {
+    PyTuple_SET_ITEM(tuple, 2, d);
+    Py_INCREF(d);
+  }
+  resultobj = wrapper(a, tuple);
+  result = resultobj ? 0 : -1;
+  Py_DECREF(tuple);
+  Py_XDECREF(resultobj);
+  return result;
+}
+
+#define SWIGPY_SSIZEARGFUNC_CLOSURE(wrapper)				\
+SWIGINTERN PyObject *							\
+wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) {		\
+  return SwigPyBuiltin_funpack_ssizeargfunc_closure(wrapper, a, b);	\
+}
+SWIGINTERN PyObject *
+SwigPyBuiltin_funpack_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
+  PyObject *tuple, *result;
+  tuple = PyTuple_New(1);
+  assert(tuple);
+  PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
+  result = wrapper(a, tuple);
+  Py_DECREF(tuple);
+  return result;
+}
+
+#define SWIGPY_FUNPACK_SSIZEARGFUNC_CLOSURE(wrapper)			\
+SWIGINTERN PyObject *							\
+wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) {		\
+  return SwigPyBuiltin_ssizeargfunc_closure(wrapper, a, b);		\
+}
+SWIGINTERN PyObject *
+SwigPyBuiltin_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
+  PyObject *arg, *result;
+  arg = _PyLong_FromSsize_t(b);
+  result = wrapper(a, arg);
+  Py_DECREF(arg);
+  return result;
+}
+
+#define SWIGPY_SSIZEOBJARGPROC_CLOSURE(wrapper)					\
+SWIGINTERN int									\
+wrapper##_ssizeobjargproc_closure(PyObject *a, Py_ssize_t b, PyObject *c) {	\
+  return SwigPyBuiltin_ssizeobjargproc_closure(wrapper, a, b, c);		\
+}
+SWIGINTERN int
+SwigPyBuiltin_ssizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, PyObject *c) {
+  PyObject *tuple, *resultobj;
+  int result;
+  tuple = PyTuple_New(2);
+  assert(tuple);
+  PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
+  PyTuple_SET_ITEM(tuple, 1, c);
+  Py_XINCREF(c);
+  resultobj = wrapper(a, tuple);
+  result = resultobj ? 0 : -1;
+  Py_XDECREF(resultobj);
+  Py_DECREF(tuple);
+  return result;
+}
+
+#define SWIGPY_OBJOBJARGPROC_CLOSURE(wrapper)					\
+SWIGINTERN int									\
+wrapper##_objobjargproc_closure(PyObject *a, PyObject *b, PyObject *c) {	\
+  return SwigPyBuiltin_objobjargproc_closure(wrapper, a, b, c);			\
+}
+SWIGINTERN int
+SwigPyBuiltin_objobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
+  PyObject *tuple, *resultobj;
+  int result;
+  tuple = PyTuple_New(c ? 2 : 1);
+  assert(tuple);
+  PyTuple_SET_ITEM(tuple, 0, b);
+  Py_XINCREF(b);
+  if (c) {
+    PyTuple_SET_ITEM(tuple, 1, c);
+    Py_XINCREF(c);
+  }
+  resultobj = wrapper(a, tuple);
+  result = resultobj ? 0 : -1;
+  Py_XDECREF(resultobj);
+  Py_DECREF(tuple);
+  return result;
+}
+
+#define SWIGPY_REPRFUNC_CLOSURE(wrapper)		\
+SWIGINTERN PyObject *					\
+wrapper##_reprfunc_closure(PyObject *a) {		\
+  return SwigPyBuiltin_reprfunc_closure(wrapper, a);	\
+}
+SWIGINTERN PyObject *
+SwigPyBuiltin_reprfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
+  return wrapper(a, NULL);
+}
+
+#define SWIGPY_HASHFUNC_CLOSURE(wrapper)		\
+SWIGINTERN Py_hash_t					\
+wrapper##_hashfunc_closure(PyObject *a) {		\
+  return SwigPyBuiltin_hashfunc_closure(wrapper, a);	\
+}
+SWIGINTERN Py_hash_t
+SwigPyBuiltin_hashfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
+  PyObject *pyresult;
+  Py_hash_t result;
+  pyresult = wrapper(a, NULL);
+  if (!pyresult)
+    return -1;
+  result = SWIG_PyNumber_AsPyHash(pyresult);
+  Py_DECREF(pyresult);
+  return result;
+}
+
+#define SWIGPY_ITERNEXTFUNC_CLOSURE(wrapper)		\
+SWIGINTERN PyObject *					\
+wrapper##_iternextfunc_closure(PyObject *a) {		\
+  return SwigPyBuiltin_iternextfunc_closure(wrapper, a);\
+}
+SWIGINTERN PyObject *
+SwigPyBuiltin_iternextfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
+  return wrapper(a, NULL);
+}
+
+/* End of callback function macros for use in PyTypeObject */
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/share/swig/3.0.12/python/carrays.i b/share/swig/3.0.12/python/carrays.i
new file mode 100644
index 0000000..74b2be9
--- /dev/null
+++ b/share/swig/3.0.12/python/carrays.i
@@ -0,0 +1,13 @@
+%define %array_class(TYPE,NAME)
+#if defined(SWIGPYTHON_BUILTIN)
+  %feature("python:slot", "sq_item", functype="ssizeargfunc") NAME::__getitem__;
+  %feature("python:slot", "sq_ass_item", functype="ssizeobjargproc") NAME::__setitem__;
+#endif
+%array_class_wrap(TYPE,NAME,__getitem__,__setitem__)
+%enddef
+
+%include <typemaps/carrays.swg>
+
+
+
+
diff --git a/share/swig/2.0.11/python/ccomplex.i b/share/swig/3.0.12/python/ccomplex.i
index 28872b9..28872b9 100644
--- a/share/swig/2.0.11/python/ccomplex.i
+++ b/share/swig/3.0.12/python/ccomplex.i
diff --git a/share/swig/2.0.11/ruby/cdata.i b/share/swig/3.0.12/python/cdata.i
index 3679659..3679659 100644
--- a/share/swig/2.0.11/ruby/cdata.i
+++ b/share/swig/3.0.12/python/cdata.i
diff --git a/share/swig/2.0.11/python/cmalloc.i b/share/swig/3.0.12/python/cmalloc.i
index 248f06b..248f06b 100644
--- a/share/swig/2.0.11/python/cmalloc.i
+++ b/share/swig/3.0.12/python/cmalloc.i
diff --git a/share/swig/2.0.11/python/cni.i b/share/swig/3.0.12/python/cni.i
index 10a1403..10a1403 100644
--- a/share/swig/2.0.11/python/cni.i
+++ b/share/swig/3.0.12/python/cni.i
diff --git a/share/swig/3.0.12/python/complex.i b/share/swig/3.0.12/python/complex.i
new file mode 100644
index 0000000..4c3b3c5
--- /dev/null
+++ b/share/swig/3.0.12/python/complex.i
@@ -0,0 +1,6 @@
+#ifdef __cplusplus
+%include <std_complex.i>
+#else
+%include <ccomplex.i>
+#endif
+
diff --git a/share/swig/2.0.11/python/cpointer.i b/share/swig/3.0.12/python/cpointer.i
index d824792..d824792 100644
--- a/share/swig/2.0.11/python/cpointer.i
+++ b/share/swig/3.0.12/python/cpointer.i
diff --git a/share/swig/2.0.11/python/cstring.i b/share/swig/3.0.12/python/cstring.i
index ede9c59..ede9c59 100644
--- a/share/swig/2.0.11/python/cstring.i
+++ b/share/swig/3.0.12/python/cstring.i
diff --git a/share/swig/2.0.11/python/cwstring.i b/share/swig/3.0.12/python/cwstring.i
index 2824d9c..2824d9c 100644
--- a/share/swig/2.0.11/python/cwstring.i
+++ b/share/swig/3.0.12/python/cwstring.i
diff --git a/share/swig/2.0.11/python/defarg.swg b/share/swig/3.0.12/python/defarg.swg
index 10c9916..10c9916 100644
--- a/share/swig/2.0.11/python/defarg.swg
+++ b/share/swig/3.0.12/python/defarg.swg
diff --git a/share/swig/3.0.12/python/director.swg b/share/swig/3.0.12/python/director.swg
new file mode 100644
index 0000000..4bdc94d
--- /dev/null
+++ b/share/swig/3.0.12/python/director.swg
@@ -0,0 +1,429 @@
+/* -----------------------------------------------------------------------------
+ * director.swg
+ *
+ * This file contains support for director classes so that Python proxy
+ * methods can be called from C++.
+ * ----------------------------------------------------------------------------- */
+
+#ifndef SWIG_DIRECTOR_PYTHON_HEADER_
+#define SWIG_DIRECTOR_PYTHON_HEADER_
+
+#include <string>
+#include <iostream>
+#include <exception>
+#include <vector>
+#include <map>
+
+
+/*
+  Use -DSWIG_PYTHON_DIRECTOR_NO_VTABLE if you don't want to generate a 'virtual
+  table', and avoid multiple GetAttr calls to retrieve the python
+  methods.
+*/
+
+#ifndef SWIG_PYTHON_DIRECTOR_NO_VTABLE
+#ifndef SWIG_PYTHON_DIRECTOR_VTABLE
+#define SWIG_PYTHON_DIRECTOR_VTABLE
+#endif
+#endif
+
+
+
+/*
+  Use -DSWIG_DIRECTOR_NO_UEH if you prefer to avoid the use of the
+  Undefined Exception Handler provided by swig.
+*/
+#ifndef SWIG_DIRECTOR_NO_UEH
+#ifndef SWIG_DIRECTOR_UEH
+#define SWIG_DIRECTOR_UEH
+#endif
+#endif
+
+
+/*
+  Use -DSWIG_DIRECTOR_NORTTI if you prefer to avoid the use of the
+  native C++ RTTI and dynamic_cast<>. But be aware that directors
+  could stop working when using this option.
+*/
+#ifdef SWIG_DIRECTOR_NORTTI
+/*
+   When we don't use the native C++ RTTI, we implement a minimal one
+   only for Directors.
+*/
+# ifndef SWIG_DIRECTOR_RTDIR
+# define SWIG_DIRECTOR_RTDIR
+
+namespace Swig {
+  class Director;
+  SWIGINTERN std::map<void *, Director *>& get_rtdir_map() {
+    static std::map<void *, Director *> rtdir_map;
+    return rtdir_map;
+  }
+
+  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *rtdir) {
+    get_rtdir_map()[vptr] = rtdir;
+  }
+
+  SWIGINTERNINLINE Director *get_rtdir(void *vptr) {
+    std::map<void *, Director *>::const_iterator pos = get_rtdir_map().find(vptr);
+    Director *rtdir = (pos != get_rtdir_map().end()) ? pos->second : 0;
+    return rtdir;
+  }
+}
+# endif /* SWIG_DIRECTOR_RTDIR */
+
+# define SWIG_DIRECTOR_CAST(ARG) Swig::get_rtdir(static_cast<void *>(ARG))
+# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) Swig::set_rtdir(static_cast<void *>(ARG1), ARG2)
+
+#else
+
+# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG)
+# define SWIG_DIRECTOR_RGTR(ARG1, ARG2)
+
+#endif /* SWIG_DIRECTOR_NORTTI */
+
+extern "C" {
+  struct swig_type_info;
+}
+
+namespace Swig {
+
+  /* memory handler */
+  struct GCItem {
+    virtual ~GCItem() {}
+
+    virtual int get_own() const {
+      return 0;
+    }
+  };
+
+  struct GCItem_var {
+    GCItem_var(GCItem *item = 0) : _item(item) {
+    }
+
+    GCItem_var& operator=(GCItem *item) {
+      GCItem *tmp = _item;
+      _item = item;
+      delete tmp;
+      return *this;
+    }
+
+    ~GCItem_var() {
+      delete _item;
+    }
+
+    GCItem * operator->() const {
+      return _item;
+    }
+
+  private:
+    GCItem *_item;
+  };
+
+  struct GCItem_Object : GCItem {
+    GCItem_Object(int own) : _own(own) {
+    }
+
+    virtual ~GCItem_Object() {
+    }
+
+    int get_own() const {
+      return _own;
+    }
+
+  private:
+    int _own;
+  };
+
+  template <typename Type>
+  struct GCItem_T : GCItem {
+    GCItem_T(Type *ptr) : _ptr(ptr) {
+    }
+
+    virtual ~GCItem_T() {
+      delete _ptr;
+    }
+
+  private:
+    Type *_ptr;
+  };
+
+  template <typename Type>
+  struct GCArray_T : GCItem {
+    GCArray_T(Type *ptr) : _ptr(ptr) {
+    }
+
+    virtual ~GCArray_T() {
+      delete[] _ptr;
+    }
+
+  private:
+    Type *_ptr;
+  };
+
+  /* base class for director exceptions */
+  class DirectorException : public std::exception {
+  protected:
+    std::string swig_msg;
+  public:
+    DirectorException(PyObject *error, const char *hdr ="", const char *msg ="") : swig_msg(hdr) {
+      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+      if (msg[0]) {
+        swig_msg += " ";
+        swig_msg += msg;
+      }
+      if (!PyErr_Occurred()) {
+        PyErr_SetString(error, what());
+      }
+      SWIG_PYTHON_THREAD_END_BLOCK;
+    }
+
+    virtual ~DirectorException() throw() {
+    }
+
+    /* Deprecated, use what() instead */
+    const char *getMessage() const {
+      return what();
+    }
+
+    const char *what() const throw() {
+      return swig_msg.c_str();
+    }
+
+    static void raise(PyObject *error, const char *msg) {
+      throw DirectorException(error, msg);
+    }
+
+    static void raise(const char *msg) {
+      raise(PyExc_RuntimeError, msg);
+    }
+  };
+
+  /* unknown exception handler  */
+  class UnknownExceptionHandler {
+#ifdef SWIG_DIRECTOR_UEH
+    static void handler() {
+      try {
+        throw;
+      } catch (DirectorException& e) {
+        std::cerr << "SWIG Director exception caught:" << std::endl
+                  << e.what() << std::endl;
+      } catch (std::exception& e) {
+        std::cerr << "std::exception caught: "<< e.what() << std::endl;
+      } catch (...) {
+        std::cerr << "Unknown exception caught." << std::endl;
+      }
+
+      std::cerr << std::endl
+                << "Python interpreter traceback:" << std::endl;
+      PyErr_Print();
+      std::cerr << std::endl;
+
+      std::cerr << "This exception was caught by the SWIG unexpected exception handler." << std::endl
+                << "Try using %feature(\"director:except\") to avoid reaching this point." << std::endl
+                << std::endl
+                << "Exception is being re-thrown, program will likely abort/terminate." << std::endl;
+      throw;
+    }
+
+  public:
+
+    std::unexpected_handler old;
+    UnknownExceptionHandler(std::unexpected_handler nh = handler) {
+      old = std::set_unexpected(nh);
+    }
+
+    ~UnknownExceptionHandler() {
+      std::set_unexpected(old);
+    }
+#endif
+  };
+
+  /* type mismatch in the return value from a python method call */
+  class DirectorTypeMismatchException : public DirectorException {
+  public:
+    DirectorTypeMismatchException(PyObject *error, const char *msg="")
+      : DirectorException(error, "SWIG director type mismatch", msg) {
+    }
+
+    DirectorTypeMismatchException(const char *msg="")
+      : DirectorException(PyExc_TypeError, "SWIG director type mismatch", msg) {
+    }
+
+    static void raise(PyObject *error, const char *msg) {
+      throw DirectorTypeMismatchException(error, msg);
+    }
+
+    static void raise(const char *msg) {
+      throw DirectorTypeMismatchException(msg);
+    }
+  };
+
+  /* any python exception that occurs during a director method call */
+  class DirectorMethodException : public DirectorException {
+  public:
+    DirectorMethodException(const char *msg = "")
+      : DirectorException(PyExc_RuntimeError, "SWIG director method error.", msg) {
+    }
+
+    static void raise(const char *msg) {
+      throw DirectorMethodException(msg);
+    }
+  };
+
+  /* attempt to call a pure virtual method via a director method */
+  class DirectorPureVirtualException : public DirectorException {
+  public:
+    DirectorPureVirtualException(const char *msg = "")
+      : DirectorException(PyExc_RuntimeError, "SWIG director pure virtual method called", msg) {
+    }
+
+    static void raise(const char *msg) {
+      throw DirectorPureVirtualException(msg);
+    }
+  };
+
+
+#if defined(SWIG_PYTHON_THREADS)
+/*  __THREAD__ is the old macro to activate some thread support */
+# if !defined(__THREAD__)
+#   define __THREAD__ 1
+# endif
+#endif
+
+#ifdef __THREAD__
+# include "pythread.h"
+  class Guard {
+    PyThread_type_lock &mutex_;
+
+  public:
+    Guard(PyThread_type_lock & mutex) : mutex_(mutex) {
+      PyThread_acquire_lock(mutex_, WAIT_LOCK);
+    }
+
+    ~Guard() {
+      PyThread_release_lock(mutex_);
+    }
+  };
+# define SWIG_GUARD(mutex) Guard _guard(mutex)
+#else
+# define SWIG_GUARD(mutex)
+#endif
+
+  /* director base class */
+  class Director {
+  private:
+    /* pointer to the wrapped python object */
+    PyObject *swig_self;
+    /* flag indicating whether the object is owned by python or c++ */
+    mutable bool swig_disown_flag;
+
+    /* decrement the reference count of the wrapped python object */
+    void swig_decref() const {
+      if (swig_disown_flag) {
+        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+        Py_DECREF(swig_self);
+        SWIG_PYTHON_THREAD_END_BLOCK;
+      }
+    }
+
+  public:
+    /* wrap a python object. */
+    Director(PyObject *self) : swig_self(self), swig_disown_flag(false) {
+    }
+
+    /* discard our reference at destruction */
+    virtual ~Director() {
+      swig_decref();
+    }
+
+    /* return a pointer to the wrapped python object */
+    PyObject *swig_get_self() const {
+      return swig_self;
+    }
+
+    /* acquire ownership of the wrapped python object (the sense of "disown" is from python) */
+    void swig_disown() const {
+      if (!swig_disown_flag) {
+        swig_disown_flag=true;
+        swig_incref();
+      }
+    }
+
+    /* increase the reference count of the wrapped python object */
+    void swig_incref() const {
+      if (swig_disown_flag) {
+        Py_INCREF(swig_self);
+      }
+    }
+
+    /* methods to implement pseudo protected director members */
+    virtual bool swig_get_inner(const char * /* swig_protected_method_name */) const {
+      return true;
+    }
+
+    virtual void swig_set_inner(const char * /* swig_protected_method_name */, bool /* swig_val */) const {
+    }
+
+  /* ownership management */
+  private:
+    typedef std::map<void *, GCItem_var> swig_ownership_map;
+    mutable swig_ownership_map swig_owner;
+#ifdef __THREAD__
+    static PyThread_type_lock swig_mutex_own;
+#endif
+
+  public:
+    template <typename Type>
+    void swig_acquire_ownership_array(Type *vptr) const {
+      if (vptr) {
+        SWIG_GUARD(swig_mutex_own);
+        swig_owner[vptr] = new GCArray_T<Type>(vptr);
+      }
+    }
+
+    template <typename Type>
+    void swig_acquire_ownership(Type *vptr) const {
+      if (vptr) {
+        SWIG_GUARD(swig_mutex_own);
+        swig_owner[vptr] = new GCItem_T<Type>(vptr);
+      }
+    }
+
+    void swig_acquire_ownership_obj(void *vptr, int own) const {
+      if (vptr && own) {
+        SWIG_GUARD(swig_mutex_own);
+        swig_owner[vptr] = new GCItem_Object(own);
+      }
+    }
+
+    int swig_release_ownership(void *vptr) const {
+      int own = 0;
+      if (vptr) {
+        SWIG_GUARD(swig_mutex_own);
+        swig_ownership_map::iterator iter = swig_owner.find(vptr);
+        if (iter != swig_owner.end()) {
+          own = iter->second->get_own();
+          swig_owner.erase(iter);
+        }
+      }
+      return own;
+    }
+
+    template <typename Type>
+    static PyObject *swig_pyobj_disown(PyObject *pyobj, PyObject *SWIGUNUSEDPARM(args)) {
+      SwigPyObject *sobj = (SwigPyObject *)pyobj;
+      sobj->own = 0;
+      Director *d = SWIG_DIRECTOR_CAST(reinterpret_cast<Type *>(sobj->ptr));
+      if (d)
+        d->swig_disown();
+      return PyWeakref_NewProxy(pyobj, NULL);
+    }
+  };
+
+#ifdef __THREAD__
+  PyThread_type_lock Director::swig_mutex_own = PyThread_allocate_lock();
+#endif
+}
+
+#endif
diff --git a/share/swig/3.0.12/python/embed.i b/share/swig/3.0.12/python/embed.i
new file mode 100644
index 0000000..efd0487
--- /dev/null
+++ b/share/swig/3.0.12/python/embed.i
@@ -0,0 +1,106 @@
+//
+// embed.i
+// SWIG file embedding the Python interpreter in something else.
+// This file is deprecated and no longer actively maintained, but it still
+// seems to work with Python 2.7.  Status with Python 3 is unknown.
+//
+// This file makes it possible to extend Python and all of its
+// built-in functions without having to hack its setup script.
+//
+
+
+#ifdef AUTODOC
+%subsection "embed.i"
+%text %{
+This module provides support for building a new version of the
+Python executable.  This will be necessary on systems that do
+not support shared libraries and may be necessary with C++
+extensions.  This file contains everything you need to build
+a new version of Python from include files and libraries normally
+installed with the Python language.
+
+This module will automatically grab all of the Python modules
+present in your current Python executable (including any special
+purpose modules you have enabled such as Tkinter).   Thus, you
+may need to provide additional link libraries when compiling.
+
+As far as I know, this module is C++ safe.
+%}
+#endif
+
+%wrapper %{
+
+#include <Python.h>
+
+#ifdef __cplusplus
+extern "C"
+#endif
+void SWIG_init();  /* Forward reference */
+
+#define _PyImport_Inittab swig_inittab
+
+/* Grab Python's inittab[] structure */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <config.c>
+
+#undef _PyImport_Inittab
+
+/* Now define our own version of it.
+   Hopefully someone does not have more than 1000 built-in modules */
+
+struct _inittab SWIG_Import_Inittab[1000];
+
+static int  swig_num_modules = 0;
+
+/* Function for adding modules to Python */
+
+static void swig_add_module(char *name, void (*initfunc)()) {
+	SWIG_Import_Inittab[swig_num_modules].name = name;
+	SWIG_Import_Inittab[swig_num_modules].initfunc = initfunc;
+	swig_num_modules++;
+	SWIG_Import_Inittab[swig_num_modules].name = (char *) 0;
+	SWIG_Import_Inittab[swig_num_modules].initfunc = 0;
+}
+
+/* Function to add all of Python's built-in modules to our interpreter */
+
+static void swig_add_builtin() {
+	int i = 0;
+	while (swig_inittab[i].name) {
+		swig_add_module(swig_inittab[i].name, swig_inittab[i].initfunc);
+		i++;
+	}
+#ifdef SWIGMODINIT
+	SWIGMODINIT
+#endif
+	/* Add SWIG builtin function */
+	swig_add_module(SWIG_name, SWIG_init);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int Py_Main(int, char **);
+
+#ifdef __cplusplus
+}
+#endif
+
+extern struct _inittab *PyImport_Inittab;
+
+int
+main(int argc, char **argv) {
+	swig_add_builtin();
+	PyImport_Inittab = SWIG_Import_Inittab;
+	return Py_Main(argc,argv);
+}
+
+%}
diff --git a/share/swig/2.0.11/octave/exception.i b/share/swig/3.0.12/python/exception.i
index bb0b15c..bb0b15c 100644
--- a/share/swig/2.0.11/octave/exception.i
+++ b/share/swig/3.0.12/python/exception.i
diff --git a/share/swig/2.0.11/python/factory.i b/share/swig/3.0.12/python/factory.i
index 46a0a87..46a0a87 100644
--- a/share/swig/2.0.11/python/factory.i
+++ b/share/swig/3.0.12/python/factory.i
diff --git a/share/swig/2.0.11/python/file.i b/share/swig/3.0.12/python/file.i
index 359c34d..359c34d 100644
--- a/share/swig/2.0.11/python/file.i
+++ b/share/swig/3.0.12/python/file.i
diff --git a/share/swig/2.0.11/python/implicit.i b/share/swig/3.0.12/python/implicit.i
index 152c2b0..152c2b0 100644
--- a/share/swig/2.0.11/python/implicit.i
+++ b/share/swig/3.0.12/python/implicit.i
diff --git a/share/swig/2.0.11/python/jstring.i b/share/swig/3.0.12/python/jstring.i
index bda9523..bda9523 100644
--- a/share/swig/2.0.11/python/jstring.i
+++ b/share/swig/3.0.12/python/jstring.i
diff --git a/share/swig/3.0.12/python/pyabc.i b/share/swig/3.0.12/python/pyabc.i
new file mode 100644
index 0000000..12ce659
--- /dev/null
+++ b/share/swig/3.0.12/python/pyabc.i
@@ -0,0 +1,10 @@
+%define %pythonabc(Type, Abc)
+  %feature("python:abc", #Abc) Type;
+%enddef
+%pythoncode %{import collections%}
+%pythonabc(std::vector, collections.MutableSequence);
+%pythonabc(std::list, collections.MutableSequence);
+%pythonabc(std::map, collections.MutableMapping);
+%pythonabc(std::multimap, collections.MutableMapping);
+%pythonabc(std::set, collections.MutableSet);
+%pythonabc(std::multiset, collections.MutableSet);
diff --git a/share/swig/2.0.11/python/pyapi.swg b/share/swig/3.0.12/python/pyapi.swg
index 2da05f9..2da05f9 100644
--- a/share/swig/2.0.11/python/pyapi.swg
+++ b/share/swig/3.0.12/python/pyapi.swg
diff --git a/share/swig/2.0.11/python/pybackward.swg b/share/swig/3.0.12/python/pybackward.swg
index 8305fc7..8305fc7 100644
--- a/share/swig/2.0.11/python/pybackward.swg
+++ b/share/swig/3.0.12/python/pybackward.swg
diff --git a/share/swig/2.0.11/python/pybuffer.i b/share/swig/3.0.12/python/pybuffer.i
index 121cd70..121cd70 100644
--- a/share/swig/2.0.11/python/pybuffer.i
+++ b/share/swig/3.0.12/python/pybuffer.i
diff --git a/share/swig/3.0.12/python/pyclasses.swg b/share/swig/3.0.12/python/pyclasses.swg
new file mode 100644
index 0000000..9d6299f
--- /dev/null
+++ b/share/swig/3.0.12/python/pyclasses.swg
@@ -0,0 +1,157 @@
+#ifdef __cplusplus
+
+/*
+  SwigPtr_PyObject is used as a replacement of PyObject *, where
+  the INCREF/DECREF are applied as needed.
+
+  You can use SwigPtr_PyObject in a container, such as
+  
+     std::vector<SwigPtr_PyObject>;
+
+  or as a member variable:
+  
+     struct A {
+       SwigPtr_PyObject obj;
+       A(PyObject *o) : _obj(o) {
+       }
+     };
+
+   or as a input/output value 
+
+     SwigPtr_PyObject func(SwigPtr_PyObject obj) {     
+       SwigPtr_PyObject out = PyString_FromFormat("hello %s", PyObject_AsString(obj));
+       Py_DECREF(out);
+       return out;
+     }
+
+   just remember to pair the object creation with the proper DECREF,
+   the same as with plain PyObject *ptr, since SwigPtr_PyObject always add
+   one reference at construction.
+
+   SwigPtr_PyObject is 'visible' at the wrapped side, so you can do:
+
+
+      %template(pyvector) std::vector<swig::SwigPtr_PyObject>;
+
+   and all the proper typemaps will be used.
+   
+*/
+
+namespace swig {
+  %ignore SwigPtr_PyObject;
+  struct SwigPtr_PyObject {};
+  %apply PyObject * {SwigPtr_PyObject};
+  %apply PyObject * const& {SwigPtr_PyObject const&};
+
+  %typemap(typecheck,precedence=SWIG_TYPECHECK_SWIGOBJECT,noblock=1) SwigPtr_PyObject const& "$1 = ($input != 0);";
+
+
+  /* For output */
+  %typemap(out,noblock=1)  SwigPtr_PyObject {
+    $result = (PyObject *)$1;
+    Py_INCREF($result);
+  }
+  
+  %typemap(out,noblock=1)  SwigPtr_PyObject const & {
+    $result = (PyObject *)*$1;
+    Py_INCREF($result);
+  }
+  
+}
+
+%{
+namespace swig {
+  class SwigPtr_PyObject {
+  protected:
+    PyObject *_obj;
+
+  public:
+    SwigPtr_PyObject() :_obj(0)
+    {
+    }
+
+    SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
+    {
+      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+      Py_XINCREF(_obj);      
+      SWIG_PYTHON_THREAD_END_BLOCK;
+    }
+    
+    SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
+    {
+      if (initial_ref) {
+        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+        Py_XINCREF(_obj);
+        SWIG_PYTHON_THREAD_END_BLOCK;
+      }
+    }
+    
+    SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) 
+    {
+      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+      Py_XINCREF(item._obj);
+      Py_XDECREF(_obj);
+      _obj = item._obj;
+      SWIG_PYTHON_THREAD_END_BLOCK;
+      return *this;      
+    }
+    
+    ~SwigPtr_PyObject() 
+    {
+      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+      Py_XDECREF(_obj);
+      SWIG_PYTHON_THREAD_END_BLOCK;
+    }
+    
+    operator PyObject *() const
+    {
+      return _obj;
+    }
+
+    PyObject *operator->() const
+    {
+      return _obj;
+    }
+  };
+}
+%}
+
+/*
+  SwigVar_PyObject is used to manage 'in the scope' PyObject * variables,
+  as in
+
+  int func () {
+    SwigVar_PyObject obj = PyString_FromString("hello");
+  }
+
+  ie, 'obj' is created and destructed in the same scope from
+  a python object that carries at least one reference value.
+  
+  SwigVar_PyObject just take care of applying the proper Py_DECREF.
+
+  Hence, this class is purely internal and not visible at the wrapped side.
+ */
+namespace swig {
+  %ignore SwigVar_PyObject;
+  struct SwigVar_PyObject {};
+  %apply PyObject * {SwigVar_PyObject};
+  %apply PyObject * const& {SwigVar_PyObject const&};
+}
+
+%{
+namespace swig {
+  struct SwigVar_PyObject : SwigPtr_PyObject {
+    SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
+    
+    SwigVar_PyObject & operator = (PyObject* obj)
+    {
+      Py_XDECREF(_obj);
+      _obj = obj;
+      return *this;      
+    }
+  };
+}
+%}
+
+
+#endif
diff --git a/share/swig/3.0.12/python/pycomplex.swg b/share/swig/3.0.12/python/pycomplex.swg
new file mode 100644
index 0000000..087c50f
--- /dev/null
+++ b/share/swig/3.0.12/python/pycomplex.swg
@@ -0,0 +1,86 @@
+/*
+  Defines the As/From converters for double/float complex, you need to
+  provide complex Type, the Name you want to use in the converters,
+  the complex Constructor method, and the Real and Imag complex
+  accessor methods.
+
+  See the std_complex.i and ccomplex.i for concrete examples.
+*/
+
+/* the common from converter */
+%define %swig_fromcplx_conv(Type, Real, Imag)
+%fragment(SWIG_From_frag(Type),"header")
+{
+SWIGINTERNINLINE PyObject*
+SWIG_From(Type)(%ifcplusplus(const Type&, Type) c)
+{
+  return PyComplex_FromDoubles(Real(c), Imag(c));
+}
+}
+%enddef
+
+/* the double case */
+%define %swig_cplxdbl_conv(Type, Constructor, Real, Imag)
+%fragment(SWIG_AsVal_frag(Type),"header",
+	  fragment=SWIG_AsVal_frag(double))
+{
+SWIGINTERN int
+SWIG_AsVal(Type) (PyObject *o, Type* val)
+{
+  if (PyComplex_Check(o)) {
+    if (val) *val = Constructor(PyComplex_RealAsDouble(o), PyComplex_ImagAsDouble(o));
+    return SWIG_OK;
+  } else {
+    double d;    
+    int res = SWIG_AddCast(SWIG_AsVal(double)(o, &d));
+    if (SWIG_IsOK(res)) {
+      if (val) *val = Constructor(d, 0.0);
+      return res;
+    }
+  }
+  return SWIG_TypeError;
+}
+}
+%swig_fromcplx_conv(Type, Real, Imag);
+%enddef
+
+/* the float case */
+%define %swig_cplxflt_conv(Type, Constructor, Real, Imag)
+%fragment(SWIG_AsVal_frag(Type),"header",
+          fragment=SWIG_AsVal_frag(float)) {
+SWIGINTERN int
+SWIG_AsVal(Type)(PyObject *o, Type *val)
+{
+  if (PyComplex_Check(o)) {
+    double re = PyComplex_RealAsDouble(o);
+    double im = PyComplex_ImagAsDouble(o);
+    if ((-FLT_MAX <= re && re <= FLT_MAX) && (-FLT_MAX <= im && im <= FLT_MAX)) {
+      if (val) *val = Constructor(%numeric_cast(re, float),
+				  %numeric_cast(im, float));
+      return SWIG_OK;
+    } else {
+      return SWIG_OverflowError;
+    }    
+  } else {
+    float re;
+    int res = SWIG_AddCast(SWIG_AsVal(float)(o, &re));
+    if (SWIG_IsOK(res)) {
+      if (val) *val = Constructor(re, 0.0);
+      return res;
+    }
+  }
+  return SWIG_TypeError;
+}
+}
+
+%swig_fromcplx_conv(Type, Real, Imag);
+%enddef
+
+#define %swig_cplxflt_convn(Type, Constructor, Real, Imag) \
+%swig_cplxflt_conv(Type, Constructor, Real, Imag)
+
+
+#define %swig_cplxdbl_convn(Type, Constructor, Real, Imag) \
+%swig_cplxdbl_conv(Type, Constructor, Real, Imag)
+
+
diff --git a/share/swig/3.0.12/python/pycontainer.swg b/share/swig/3.0.12/python/pycontainer.swg
new file mode 100644
index 0000000..d40b0ba
--- /dev/null
+++ b/share/swig/3.0.12/python/pycontainer.swg
@@ -0,0 +1,1033 @@
+/* -----------------------------------------------------------------------------
+ * pycontainer.swg
+ *
+ * Python sequence <-> C++ container wrapper
+ *
+ * This wrapper, and its iterator, allows a general use (and reuse) of
+ * the mapping between C++ and Python, thanks to the C++ templates.
+ *
+ * Of course, it needs the C++ compiler to support templates, but
+ * since we will use this wrapper with the STL containers, that should
+ * be the case.
+ * ----------------------------------------------------------------------------- */
+
+%{
+#include <iostream>
+
+#if PY_VERSION_HEX >= 0x03020000
+# define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
+#else
+# define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
+#endif
+%}
+
+
+#if !defined(SWIG_NO_EXPORT_ITERATOR_METHODS)
+# if !defined(SWIG_EXPORT_ITERATOR_METHODS)
+#  define SWIG_EXPORT_ITERATOR_METHODS SWIG_EXPORT_ITERATOR_METHODS
+# endif
+#endif
+
+%include <pyiterators.swg>
+
+/**** The PySequence C++ Wrap ***/
+
+%fragment("<stdexcept>");
+
+%include <std_except.i>
+
+%fragment(SWIG_Traits_frag(swig::SwigPtr_PyObject),"header",fragment="StdTraits") {
+namespace swig {
+  template <>  struct traits<SwigPtr_PyObject > {
+    typedef value_category category;
+    static const char* type_name() { return  "SwigPtr_PyObject"; }
+  };
+  
+  template <>  struct traits_from<SwigPtr_PyObject> {
+    typedef SwigPtr_PyObject value_type;
+    static PyObject *from(const value_type& val) {
+      PyObject *obj = static_cast<PyObject *>(val);
+      Py_XINCREF(obj);
+      return obj;
+    }
+  };
+  
+  template <> 
+  struct traits_check<SwigPtr_PyObject, value_category> {
+    static bool check(SwigPtr_PyObject) {
+      return true;
+    }
+  };
+  
+  template <>  struct traits_asval<SwigPtr_PyObject > {   
+    typedef SwigPtr_PyObject value_type;
+    static int asval(PyObject *obj, value_type *val) {
+      if (val) *val = obj;
+      return SWIG_OK;
+    }
+  };
+}
+}
+
+%fragment(SWIG_Traits_frag(swig::SwigVar_PyObject),"header",fragment="StdTraits") {
+namespace swig {
+  template <>  struct traits<SwigVar_PyObject > {
+    typedef value_category category;
+    static const char* type_name() { return  "SwigVar_PyObject"; }
+  };
+  
+  template <>  struct traits_from<SwigVar_PyObject> {
+    typedef SwigVar_PyObject value_type;
+    static PyObject *from(const value_type& val) {
+      PyObject *obj = static_cast<PyObject *>(val);
+      Py_XINCREF(obj);
+      return obj;
+    }
+  };
+  
+  template <> 
+  struct traits_check<SwigVar_PyObject, value_category> {
+    static bool check(SwigVar_PyObject) {
+      return true;
+    }
+  };
+  
+  template <>  struct traits_asval<SwigVar_PyObject > {   
+    typedef SwigVar_PyObject value_type;
+    static int asval(PyObject *obj, value_type *val) {
+      if (val) *val = obj;
+      return SWIG_OK;
+    }
+  };
+} 
+}
+
+%fragment("SwigPySequence_Base","header",fragment="<stddef.h>")
+{
+%#include <functional>
+
+namespace std {
+  template <>
+  struct less <PyObject *>
+  {
+    bool
+    operator()(PyObject * v, PyObject *w) const
+    { 
+      bool res;
+      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+      res = PyObject_RichCompareBool(v, w, Py_LT) ? true : false;
+      /* This may fall into a case of inconsistent
+               eg. ObjA > ObjX > ObjB
+               but ObjA < ObjB
+      */
+      if( PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError) )
+      {
+        /* Objects can't be compared, this mostly occurred in Python 3.0 */
+        /* Compare their ptr directly for a workaround */
+        res = (v < w);
+        PyErr_Clear();
+      }
+      SWIG_PYTHON_THREAD_END_BLOCK;
+      return res;
+    }
+  };
+
+  template <>
+  struct less <swig::SwigPtr_PyObject>
+  {
+    bool
+    operator()(const swig::SwigPtr_PyObject& v, const swig::SwigPtr_PyObject& w) const
+    {
+      return std::less<PyObject *>()(v, w);
+    }
+  };
+
+  template <>
+  struct less <swig::SwigVar_PyObject>
+  {
+    bool
+    operator()(const swig::SwigVar_PyObject& v, const swig::SwigVar_PyObject& w) const
+    {
+      return std::less<PyObject *>()(v, w);
+    }
+  };
+
+}
+
+namespace swig {
+  template <> struct traits<PyObject *> {
+    typedef value_category category;
+    static const char* type_name() { return "PyObject *"; }
+  };  
+
+  template <>  struct traits_asval<PyObject * > {   
+    typedef PyObject * value_type;
+    static int asval(PyObject *obj, value_type *val) {
+      if (val) *val = obj;
+      return SWIG_OK;
+    }
+  };
+
+  template <> 
+  struct traits_check<PyObject *, value_category> {
+    static bool check(PyObject *) {
+      return true;
+    }
+  };
+
+  template <>  struct traits_from<PyObject *> {
+    typedef PyObject * value_type;
+    static PyObject *from(const value_type& val) {
+      Py_XINCREF(val);
+      return val;
+    }
+  };
+  
+}
+
+namespace swig {
+  template <class Difference>
+  inline size_t
+  check_index(Difference i, size_t size, bool insert = false) {
+    if ( i < 0 ) {
+      if ((size_t) (-i) <= size)
+	return (size_t) (i + size);
+    } else if ( (size_t) i < size ) {
+      return (size_t) i;
+    } else if (insert && ((size_t) i == size)) {
+      return size;
+    }
+    throw std::out_of_range("index out of range");
+  }
+
+  template <class Difference>
+  void
+  slice_adjust(Difference i, Difference j, Py_ssize_t step, size_t size, Difference &ii, Difference &jj, bool insert = false) {
+    if (step == 0) {
+      throw std::invalid_argument("slice step cannot be zero");
+    } else if (step > 0) {
+      // Required range: 0 <= i < size, 0 <= j < size, i <= j
+      if (i < 0) {
+        ii = 0;
+      } else if (i < (Difference)size) {
+        ii = i;
+      } else if (insert && (i >= (Difference)size)) {
+        ii = (Difference)size;
+      }
+      if (j < 0) {
+        jj = 0;
+      } else {
+        jj = (j < (Difference)size) ? j : (Difference)size;
+      }
+      if (jj < ii)
+        jj = ii;
+    } else {
+      // Required range: -1 <= i < size-1, -1 <= j < size-1, i >= j
+      if (i < -1) {
+        ii = -1;
+      } else if (i < (Difference) size) {
+        ii = i;
+      } else if (i >= (Difference)(size-1)) {
+        ii = (Difference)(size-1);
+      }
+      if (j < -1) {
+        jj = -1;
+      } else {
+        jj = (j < (Difference)size ) ? j : (Difference)(size-1);
+      }
+      if (ii < jj)
+        ii = jj;
+    }
+  }
+
+  template <class Sequence, class Difference>
+  inline typename Sequence::iterator
+  getpos(Sequence* self, Difference i)  {
+    typename Sequence::iterator pos = self->begin();
+    std::advance(pos, check_index(i,self->size()));
+    return pos;
+  }
+
+  template <class Sequence, class Difference>
+  inline typename Sequence::const_iterator
+  cgetpos(const Sequence* self, Difference i)  {
+    typename Sequence::const_iterator pos = self->begin();
+    std::advance(pos, check_index(i,self->size()));
+    return pos;
+  }
+
+  template <class Sequence>
+  inline void
+  erase(Sequence* seq, const typename Sequence::iterator& position) {
+    seq->erase(position);
+  }
+
+  template <class Sequence>
+  struct traits_reserve {
+    static void reserve(Sequence & /*seq*/, typename Sequence::size_type /*n*/) {
+      // This should be specialized for types that support reserve
+    }
+  };
+
+  template <class Sequence, class Difference>
+  inline Sequence*
+  getslice(const Sequence* self, Difference i, Difference j, Py_ssize_t step) {
+    typename Sequence::size_type size = self->size();
+    Difference ii = 0;
+    Difference jj = 0;
+    swig::slice_adjust(i, j, step, size, ii, jj);
+
+    if (step > 0) {
+      typename Sequence::const_iterator sb = self->begin();
+      typename Sequence::const_iterator se = self->begin();
+      std::advance(sb,ii);
+      std::advance(se,jj);
+      if (step == 1) {
+        return new Sequence(sb, se);
+      } else {
+        Sequence *sequence = new Sequence();
+        swig::traits_reserve<Sequence>::reserve(*sequence, (jj - ii + step - 1) / step);
+        typename Sequence::const_iterator it = sb;
+        while (it!=se) {
+          sequence->push_back(*it);
+          for (Py_ssize_t c=0; c<step && it!=se; ++c)
+            it++;
+        }
+        return sequence;
+      } 
+    } else {
+      Sequence *sequence = new Sequence();
+      swig::traits_reserve<Sequence>::reserve(*sequence, (ii - jj - step - 1) / -step);
+      typename Sequence::const_reverse_iterator sb = self->rbegin();
+      typename Sequence::const_reverse_iterator se = self->rbegin();
+      std::advance(sb,size-ii-1);
+      std::advance(se,size-jj-1);
+      typename Sequence::const_reverse_iterator it = sb;
+      while (it!=se) {
+        sequence->push_back(*it);
+        for (Py_ssize_t c=0; c<-step && it!=se; ++c)
+          it++;
+      }
+      return sequence;
+    }
+  }
+
+  template <class Sequence, class Difference, class InputSeq>
+  inline void
+  setslice(Sequence* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) {
+    typename Sequence::size_type size = self->size();
+    Difference ii = 0;
+    Difference jj = 0;
+    swig::slice_adjust(i, j, step, size, ii, jj, true);
+    if (step > 0) {
+      if (step == 1) {
+        size_t ssize = jj - ii;
+        if (ssize <= is.size()) {
+          // expanding/staying the same size
+          swig::traits_reserve<Sequence>::reserve(*self, self->size() - ssize + is.size());
+          typename Sequence::iterator sb = self->begin();
+          typename InputSeq::const_iterator isit = is.begin();
+          std::advance(sb,ii);
+          std::advance(isit, jj - ii);
+          self->insert(std::copy(is.begin(), isit, sb), isit, is.end());
+        } else {
+          // shrinking
+          typename Sequence::iterator sb = self->begin();
+          typename Sequence::iterator se = self->begin();
+          std::advance(sb,ii);
+          std::advance(se,jj);
+          self->erase(sb,se);
+          sb = self->begin();
+          std::advance(sb,ii);
+          self->insert(sb, is.begin(), is.end());
+        }
+      } else {
+        size_t replacecount = (jj - ii + step - 1) / step;
+        if (is.size() != replacecount) {
+          char msg[1024];
+          sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
+          throw std::invalid_argument(msg);
+        }
+        typename Sequence::const_iterator isit = is.begin();
+        typename Sequence::iterator it = self->begin();
+        std::advance(it,ii);
+        for (size_t rc=0; rc<replacecount; ++rc) {
+          *it++ = *isit++;
+          for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
+            it++;
+        }
+      }
+    } else {
+      size_t replacecount = (ii - jj - step - 1) / -step;
+      if (is.size() != replacecount) {
+        char msg[1024];
+        sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
+        throw std::invalid_argument(msg);
+      }
+      typename Sequence::const_iterator isit = is.begin();
+      typename Sequence::reverse_iterator it = self->rbegin();
+      std::advance(it,size-ii-1);
+      for (size_t rc=0; rc<replacecount; ++rc) {
+        *it++ = *isit++;
+        for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
+          it++;
+      }
+    }
+  }
+
+  template <class Sequence, class Difference>
+  inline void
+  delslice(Sequence* self, Difference i, Difference j, Py_ssize_t step) {
+    typename Sequence::size_type size = self->size();
+    Difference ii = 0;
+    Difference jj = 0;
+    swig::slice_adjust(i, j, step, size, ii, jj, true);
+    if (step > 0) {
+      typename Sequence::iterator sb = self->begin();
+      std::advance(sb,ii);
+      if (step == 1) {
+        typename Sequence::iterator se = self->begin();
+        std::advance(se,jj);
+        self->erase(sb,se);
+      } else {
+        typename Sequence::iterator it = sb;
+        size_t delcount = (jj - ii + step - 1) / step;
+        while (delcount) {
+          it = self->erase(it);
+          for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
+            it++;
+          delcount--;
+        }
+      }
+    } else {
+      typename Sequence::reverse_iterator sb = self->rbegin();
+      std::advance(sb,size-ii-1);
+      typename Sequence::reverse_iterator it = sb;
+      size_t delcount = (ii - jj - step - 1) / -step;
+      while (delcount) {
+        it = typename Sequence::reverse_iterator(self->erase((++it).base()));
+        for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
+          it++;
+        delcount--;
+      }
+    }
+  }
+}
+}
+
+%fragment("SwigPySequence_Cont","header",
+	  fragment="StdTraits",
+	  fragment="SwigPySequence_Base",
+	  fragment="SwigPyIterator_T")
+{
+namespace swig
+{
+  template <class T>
+  struct SwigPySequence_Ref
+  {
+    SwigPySequence_Ref(PyObject* seq, Py_ssize_t index)
+      : _seq(seq), _index(index)
+    {
+    }
+    
+    operator T () const
+    {
+      swig::SwigVar_PyObject item = PySequence_GetItem(_seq, _index);
+      try {
+	return swig::as<T>(item, true);
+      } catch (std::exception& e) {
+	char msg[1024];
+	sprintf(msg, "in sequence element %d ", (int)_index);
+	if (!PyErr_Occurred()) {
+	  ::%type_error(swig::type_name<T>());
+	}
+	SWIG_Python_AddErrorMsg(msg);
+	SWIG_Python_AddErrorMsg(e.what());
+	throw;
+      }
+    }
+
+    SwigPySequence_Ref& operator=(const T& v)
+    {
+      PySequence_SetItem(_seq, _index, swig::from<T>(v));
+      return *this;
+    }
+
+  private:
+    PyObject* _seq;
+    Py_ssize_t _index;
+  };
+
+  template <class T>
+  struct SwigPySequence_ArrowProxy
+  {
+    SwigPySequence_ArrowProxy(const T& x): m_value(x) {}
+    const T* operator->() const { return &m_value; }
+    operator const T*() const { return &m_value; }
+    T m_value;
+  };
+
+  template <class T, class Reference >
+  struct SwigPySequence_InputIterator
+  {
+    typedef SwigPySequence_InputIterator<T, Reference > self;
+
+    typedef std::random_access_iterator_tag iterator_category;
+    typedef Reference reference;
+    typedef T value_type;
+    typedef T* pointer;
+    typedef Py_ssize_t difference_type;
+
+    SwigPySequence_InputIterator()
+    {
+    }
+
+    SwigPySequence_InputIterator(PyObject* seq, Py_ssize_t index)
+      : _seq(seq), _index(index)
+    {
+    }
+
+    reference operator*() const
+    {
+      return reference(_seq, _index);
+    }
+
+    SwigPySequence_ArrowProxy<T>
+    operator->() const {
+      return SwigPySequence_ArrowProxy<T>(operator*());
+    }
+
+    bool operator==(const self& ri) const
+    {
+      return (_index == ri._index) && (_seq == ri._seq);
+    }
+
+    bool operator!=(const self& ri) const
+    {
+      return !(operator==(ri));
+    }
+
+    self& operator ++ ()
+    {
+      ++_index;
+      return *this;
+    }
+
+    self& operator -- ()
+    {
+      --_index;
+      return *this;
+    }
+
+    self& operator += (difference_type n)
+    {
+      _index += n;
+      return *this;
+    }
+
+    self operator +(difference_type n) const
+    {
+      return self(_seq, _index + n);
+    }
+
+    self& operator -= (difference_type n)
+    {
+      _index -= n;
+      return *this;
+    }
+
+    self operator -(difference_type n) const
+    {
+      return self(_seq, _index - n);
+    }
+
+    difference_type operator - (const self& ri) const
+    {
+      return _index - ri._index;
+    }
+
+    bool operator < (const self& ri) const
+    {
+      return _index < ri._index;
+    }
+
+    reference
+    operator[](difference_type n) const
+    {
+      return reference(_seq, _index + n);
+    }
+
+  private:
+    PyObject* _seq;
+    difference_type _index;
+  };
+
+  // STL container wrapper around a Python sequence
+  template <class T>
+  struct SwigPySequence_Cont
+  {
+    typedef SwigPySequence_Ref<T> reference;
+    typedef const SwigPySequence_Ref<T> const_reference;
+    typedef T value_type;
+    typedef T* pointer;
+    typedef Py_ssize_t difference_type;
+    typedef size_t size_type;
+    typedef const pointer const_pointer;
+    typedef SwigPySequence_InputIterator<T, reference> iterator;
+    typedef SwigPySequence_InputIterator<T, const_reference> const_iterator;
+
+    SwigPySequence_Cont(PyObject* seq) : _seq(0)
+    {
+      if (!PySequence_Check(seq)) {
+	throw std::invalid_argument("a sequence is expected");
+      }
+      _seq = seq;
+      Py_INCREF(_seq);
+    }
+
+    ~SwigPySequence_Cont()
+    {
+      Py_XDECREF(_seq);
+    }
+
+    size_type size() const
+    {
+      return static_cast<size_type>(PySequence_Size(_seq));
+    }
+
+    bool empty() const
+    {
+      return size() == 0;
+    }
+
+    iterator begin()
+    {
+      return iterator(_seq, 0);
+    }
+
+    const_iterator begin() const
+    {
+      return const_iterator(_seq, 0);
+    }
+
+    iterator end()
+    {
+      return iterator(_seq, size());
+    }
+
+    const_iterator end() const
+    {
+      return const_iterator(_seq, size());
+    }
+
+    reference operator[](difference_type n)
+    {
+      return reference(_seq, n);
+    }
+
+    const_reference operator[](difference_type n)  const
+    {
+      return const_reference(_seq, n);
+    }
+
+    bool check(bool set_err = true) const
+    {
+      Py_ssize_t s = size();
+      for (Py_ssize_t i = 0; i < s; ++i) {
+	swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i);
+	if (!swig::check<value_type>(item)) {
+	  if (set_err) {
+	    char msg[1024];
+	    sprintf(msg, "in sequence element %d", (int)i);
+	    SWIG_Error(SWIG_RuntimeError, msg);
+	  }
+	  return false;
+	}
+      }
+      return true;
+    }
+
+  private:
+    PyObject* _seq;
+  };
+
+}
+}
+
+%define %swig_sequence_iterator(Sequence...)
+#if defined(SWIG_EXPORT_ITERATOR_METHODS)
+  class iterator;
+  class reverse_iterator;
+  class const_iterator;
+  class const_reverse_iterator;
+
+  %typemap(out,noblock=1,fragment="SwigPySequence_Cont")
+    iterator, reverse_iterator, const_iterator, const_reverse_iterator {
+    $result = SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &)),
+				 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+  }
+  %typemap(out,noblock=1,fragment="SwigPySequence_Cont")
+    std::pair<iterator, iterator>, std::pair<const_iterator, const_iterator> {
+    $result = PyTuple_New(2);
+    PyTuple_SetItem($result,0,SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &).first),
+						 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN));
+    PyTuple_SetItem($result,1,SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &).second),
+						 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN));    
+  }
+
+  %fragment("SwigPyPairBoolOutputIterator","header",fragment=SWIG_From_frag(bool),fragment="SwigPySequence_Cont") {}
+
+  %typemap(out,noblock=1,fragment="SwigPyPairBoolOutputIterator")
+    std::pair<iterator, bool>, std::pair<const_iterator, bool> {
+    $result = PyTuple_New(2);
+    PyTuple_SetItem($result,0,SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &).first),
+					       swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN));    
+    PyTuple_SetItem($result,1,SWIG_From(bool)(%static_cast($1,const $type &).second));
+  }
+
+  %typemap(in,noblock=1,fragment="SwigPySequence_Cont")
+    iterator(swig::SwigPyIterator *iter = 0, int res),
+    reverse_iterator(swig::SwigPyIterator *iter = 0, int res),
+    const_iterator(swig::SwigPyIterator *iter = 0, int res),
+    const_reverse_iterator(swig::SwigPyIterator *iter = 0, int res) {
+    res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+    if (!SWIG_IsOK(res) || !iter) {
+      %argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
+    } else {
+      swig::SwigPyIterator_T<$type > *iter_t = dynamic_cast<swig::SwigPyIterator_T<$type > *>(iter);
+      if (iter_t) {
+	$1 = iter_t->get_current();
+      } else {
+	%argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
+      }
+    }
+  }
+
+  %typecheck(%checkcode(ITERATOR),noblock=1,fragment="SwigPySequence_Cont")
+    iterator, reverse_iterator, const_iterator, const_reverse_iterator {
+    swig::SwigPyIterator *iter = 0;
+    int res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+    $1 = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<$type > *>(iter) != 0));
+  }
+
+  %fragment("SwigPySequence_Cont");
+
+  %newobject iterator(PyObject **PYTHON_SELF);
+  %extend  {
+    swig::SwigPyIterator* iterator(PyObject **PYTHON_SELF) {
+      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+    }
+
+#if defined(SWIGPYTHON_BUILTIN)
+  %feature("python:slot", "tp_iter", functype="getiterfunc") iterator;
+#else
+  %pythoncode %{def __iter__(self):
+    return self.iterator()%}
+#endif
+  }
+
+#endif //SWIG_EXPORT_ITERATOR_METHODS
+%enddef
+
+
+/**** The python container methods  ****/
+
+%define %swig_container_methods(Container...)
+
+/* deprecated in Python 2 */
+#if 1
+  %newobject __getslice__;
+#endif
+  %newobject __getitem__(PySliceObject *slice);
+
+#if defined(SWIGPYTHON_BUILTIN)
+  %feature("python:slot", "nb_nonzero", functype="inquiry") __nonzero__;
+  %feature("python:slot", "sq_length", functype="lenfunc") __len__;
+#endif // SWIGPYTHON_BUILTIN
+
+  %extend {
+    bool __nonzero__() const {
+      return !(self->empty());
+    }
+
+    /* Alias for Python 3 compatibility */
+    bool __bool__() const {
+      return !(self->empty());
+    }
+
+    size_type __len__() const {
+      return self->size();
+    }
+  }
+%enddef
+
+
+
+%define %swig_sequence_methods_common(Sequence...)
+  %swig_sequence_iterator(%arg(Sequence))
+  %swig_container_methods(%arg(Sequence))
+
+  %fragment("SwigPySequence_Base");
+
+#if defined(SWIGPYTHON_BUILTIN)
+  //%feature("python:slot", "sq_item", functype="ssizeargfunc") __getitem__;
+  //%feature("python:slot", "sq_slice", functype="ssizessizeargfunc") __getslice__;
+  //%feature("python:slot", "sq_ass_item", functype="ssizeobjargproc") __setitem__;
+  //%feature("python:slot", "sq_ass_slice", functype="ssizessizeobjargproc") __setslice__;
+  %feature("python:slot", "mp_subscript", functype="binaryfunc") __getitem__;
+  %feature("python:slot", "mp_ass_subscript", functype="objobjargproc") __setitem__;
+#endif // SWIGPYTHON_BUILTIN
+
+  %extend {
+    /* typemap for slice object support */
+    %typemap(in) PySliceObject* {
+      if (!PySlice_Check($input)) {
+        %argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
+      }
+      $1 = (PySliceObject *) $input;
+    }
+    %typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER) PySliceObject* {
+      $1 = PySlice_Check($input);
+    }
+
+/* deprecated in Python 2 */
+#if 1
+    Sequence* __getslice__(difference_type i, difference_type j) throw (std::out_of_range, std::invalid_argument) {
+      return swig::getslice(self, i, j, 1);
+    }
+
+    void __setslice__(difference_type i, difference_type j) throw (std::out_of_range, std::invalid_argument) {
+      swig::setslice(self, i, j, 1, Sequence());
+    }
+
+    void __setslice__(difference_type i, difference_type j, const Sequence& v) throw (std::out_of_range, std::invalid_argument) {
+      swig::setslice(self, i, j, 1, v);
+    }
+
+    void __delslice__(difference_type i, difference_type j) throw (std::out_of_range, std::invalid_argument) {
+      swig::delslice(self, i, j, 1);
+    }
+#endif
+
+    void __delitem__(difference_type i) throw (std::out_of_range, std::invalid_argument) {
+      swig::erase(self, swig::getpos(self, i));
+    }
+
+    /* Overloaded methods for Python 3 compatibility 
+     * (Also useful in Python 2.x)
+     */
+    Sequence* __getitem__(PySliceObject *slice) throw (std::out_of_range, std::invalid_argument) {
+      Py_ssize_t i, j, step;
+      if( !PySlice_Check(slice) ) {
+        SWIG_Error(SWIG_TypeError, "Slice object expected.");
+        return NULL;
+      }
+      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+      Sequence::difference_type id = i;
+      Sequence::difference_type jd = j;
+      return swig::getslice(self, id, jd, step);
+    }
+
+    void __setitem__(PySliceObject *slice, const Sequence& v) throw (std::out_of_range, std::invalid_argument) {
+      Py_ssize_t i, j, step;
+      if( !PySlice_Check(slice) ) {
+        SWIG_Error(SWIG_TypeError, "Slice object expected.");
+        return;
+      }
+      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+      Sequence::difference_type id = i;
+      Sequence::difference_type jd = j;
+      swig::setslice(self, id, jd, step, v);
+    }
+
+    void __setitem__(PySliceObject *slice) throw (std::out_of_range, std::invalid_argument) {
+      Py_ssize_t i, j, step;
+      if( !PySlice_Check(slice) ) {
+        SWIG_Error(SWIG_TypeError, "Slice object expected.");
+        return;
+      }
+      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+      Sequence::difference_type id = i;
+      Sequence::difference_type jd = j;
+      swig::delslice(self, id, jd, step);
+    }
+
+    void __delitem__(PySliceObject *slice) throw (std::out_of_range, std::invalid_argument) {
+      Py_ssize_t i, j, step;
+      if( !PySlice_Check(slice) ) {
+        SWIG_Error(SWIG_TypeError, "Slice object expected.");
+        return;
+      }
+      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+      Sequence::difference_type id = i;
+      Sequence::difference_type jd = j;
+      swig::delslice(self, id, jd, step);
+    }
+
+  }
+%enddef
+
+%define %swig_sequence_methods_non_resizable(Sequence...)
+  %swig_sequence_methods_common(%arg(Sequence))
+  %extend {
+    const value_type& __getitem__(difference_type i) const throw (std::out_of_range) {
+      return *(swig::cgetpos(self, i));
+    }
+
+    void __setitem__(difference_type i, const value_type& x) throw (std::out_of_range) {
+      *(swig::getpos(self,i)) = x;
+    }
+
+#if defined(SWIGPYTHON_BUILTIN)
+    // This will be called through the mp_ass_subscript slot to delete an entry.
+    void __setitem__(difference_type i) throw (std::out_of_range, std::invalid_argument) {
+      swig::erase(self, swig::getpos(self, i));
+    }
+#endif
+
+  }
+%enddef
+
+%define %swig_sequence_methods(Sequence...)
+  %swig_sequence_methods_non_resizable(%arg(Sequence))
+  %extend {
+    value_type pop() throw (std::out_of_range) {
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      Sequence::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
+
+    void append(const value_type& x) {
+      self->push_back(x);
+    }
+  }
+%enddef
+
+%define %swig_sequence_methods_non_resizable_val(Sequence...)
+  %swig_sequence_methods_common(%arg(Sequence))
+  %extend {
+    value_type __getitem__(difference_type i) throw (std::out_of_range) {
+      return *(swig::cgetpos(self, i));
+    }
+
+    void __setitem__(difference_type i, value_type x) throw (std::out_of_range) {
+      *(swig::getpos(self,i)) = x;
+    }
+
+#if defined(SWIGPYTHON_BUILTIN)
+    // This will be called through the mp_ass_subscript slot to delete an entry.
+    void __setitem__(difference_type i) throw (std::out_of_range, std::invalid_argument) {
+      swig::erase(self, swig::getpos(self, i));
+    }
+#endif
+  }
+%enddef
+
+%define %swig_sequence_methods_val(Sequence...)
+  %swig_sequence_methods_non_resizable_val(%arg(Sequence))
+  %extend {
+    value_type pop() throw (std::out_of_range) {
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      Sequence::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
+
+    void append(value_type x) {
+      self->push_back(x);
+    }
+  }
+%enddef
+
+
+
+//
+// Common fragments
+//
+
+%fragment("StdSequenceTraits","header",
+	  fragment="StdTraits",
+	  fragment="SwigPySequence_Cont")
+{
+namespace swig {
+  template <class SwigPySeq, class Seq>
+  inline void
+  assign(const SwigPySeq& swigpyseq, Seq* seq) {
+    // seq->assign(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented
+    typedef typename SwigPySeq::value_type value_type;
+    typename SwigPySeq::const_iterator it = swigpyseq.begin();
+    for (;it != swigpyseq.end(); ++it) {
+      seq->insert(seq->end(),(value_type)(*it));
+    }
+  }
+
+  template <class Seq, class T = typename Seq::value_type >
+  struct traits_asptr_stdseq {
+    typedef Seq sequence;
+    typedef T value_type;
+
+    static int asptr(PyObject *obj, sequence **seq) {
+      if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) {
+	sequence *p;
+	swig_type_info *descriptor = swig::type_info<sequence>();
+	if (descriptor && SWIG_IsOK(::SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0))) {
+	  if (seq) *seq = p;
+	  return SWIG_OLDOBJ;
+	}
+      } else if (PySequence_Check(obj)) {
+	try {
+	  SwigPySequence_Cont<value_type> swigpyseq(obj);
+	  if (seq) {
+	    sequence *pseq = new sequence();
+	    assign(swigpyseq, pseq);
+	    *seq = pseq;
+	    return SWIG_NEWOBJ;
+	  } else {
+	    return swigpyseq.check() ? SWIG_OK : SWIG_ERROR;
+	  }
+	} catch (std::exception& e) {
+	  if (seq) {
+	    if (!PyErr_Occurred()) {
+	      PyErr_SetString(PyExc_TypeError, e.what());
+	    }
+	  }
+	  return SWIG_ERROR;
+	}
+      }
+      return SWIG_ERROR;
+    }
+  };
+
+  template <class Seq, class T = typename Seq::value_type >
+  struct traits_from_stdseq {
+    typedef Seq sequence;
+    typedef T value_type;
+    typedef typename Seq::size_type size_type;
+    typedef typename sequence::const_iterator const_iterator;
+
+    static PyObject *from(const sequence& seq) {
+%#ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS
+      swig_type_info *desc = swig::type_info<sequence>();
+      if (desc && desc->clientdata) {
+	return SWIG_InternalNewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
+      }
+%#endif
+      size_type size = seq.size();
+      if (size <= (size_type)INT_MAX) {
+	PyObject *obj = PyTuple_New((Py_ssize_t)size);
+	Py_ssize_t i = 0;
+	for (const_iterator it = seq.begin(); it != seq.end(); ++it, ++i) {
+	  PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
+	}
+	return obj;
+      } else {
+	PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python");
+	return NULL;
+      }
+    }
+  };
+}
+}
diff --git a/share/swig/3.0.12/python/pydocs.swg b/share/swig/3.0.12/python/pydocs.swg
new file mode 100644
index 0000000..969af92
--- /dev/null
+++ b/share/swig/3.0.12/python/pydocs.swg
@@ -0,0 +1,24 @@
+
+// Documentation for use with the autodoc feature.
+
+#ifdef SWIG_DOC_DOXYGEN_STYLE
+%typemap(doc) SWIGTYPE "@param $1_name $1_type";
+%typemap(doc) SWIGTYPE * "@param $1_name $1_type";
+%typemap(doc) const SWIGTYPE & "@param $1_name $1_type";
+%typemap(doc) const SWIGTYPE && "@param $1_name $1_type";
+%typemap(doc) enum SWIGTYPE "@param $1_name enum $1_type";
+
+%typemap(doc) SWIGTYPE *INOUT, SWIGTYPE &INOUT "@param $1_name $1_type (input/output)";
+%typemap(doc) SWIGTYPE *INPUT, SWIGTYPE &INPUT "@param $1_name $1_type (input)";
+%typemap(doc) SWIGTYPE *OUTPUT, SWIGTYPE &OUTPUT "@param $1_name $1_type (output)";
+#else
+%typemap(doc) SWIGTYPE "$1_name: $1_type";
+%typemap(doc) SWIGTYPE * "$1_name: $1_type";
+%typemap(doc) const SWIGTYPE & "$1_name: $1_type";
+%typemap(doc) const SWIGTYPE && "$1_name: $1_type";
+%typemap(doc) enum SWIGTYPE "$1_name: enum $1_type";
+
+%typemap(doc) SWIGTYPE *INOUT, SWIGTYPE &INOUT "$1_name: $1_type (input/output)";
+%typemap(doc) SWIGTYPE *INPUT, SWIGTYPE &INPUT "$1_name: $1_type (input)";
+%typemap(doc) SWIGTYPE *OUTPUT, SWIGTYPE &OUTPUT "$1_name: $1_type (output)";
+#endif
diff --git a/share/swig/2.0.11/python/pyerrors.swg b/share/swig/3.0.12/python/pyerrors.swg
index fe73135..fe73135 100644
--- a/share/swig/2.0.11/python/pyerrors.swg
+++ b/share/swig/3.0.12/python/pyerrors.swg
diff --git a/share/swig/2.0.11/python/pyfragments.swg b/share/swig/3.0.12/python/pyfragments.swg
index 535a45b..535a45b 100644
--- a/share/swig/2.0.11/python/pyfragments.swg
+++ b/share/swig/3.0.12/python/pyfragments.swg
diff --git a/share/swig/3.0.12/python/pyhead.swg b/share/swig/3.0.12/python/pyhead.swg
new file mode 100644
index 0000000..55eb95a
--- /dev/null
+++ b/share/swig/3.0.12/python/pyhead.swg
@@ -0,0 +1,215 @@
+/* Compatibility macros for Python 3 */
+#if PY_VERSION_HEX >= 0x03000000
+
+#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
+#define PyInt_Check(x) PyLong_Check(x)
+#define PyInt_AsLong(x) PyLong_AsLong(x)
+#define PyInt_FromLong(x) PyLong_FromLong(x)
+#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
+#define PyString_Check(name) PyBytes_Check(name)
+#define PyString_FromString(x) PyUnicode_FromString(x)
+#define PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)
+#define PyString_AsString(str) PyBytes_AsString(str)
+#define PyString_Size(str) PyBytes_Size(str)	
+#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
+#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
+#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
+#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
+
+#endif
+
+#ifndef Py_TYPE
+#  define Py_TYPE(op) ((op)->ob_type)
+#endif
+
+/* SWIG APIs for compatibility of both Python 2 & 3 */
+
+#if PY_VERSION_HEX >= 0x03000000
+#  define SWIG_Python_str_FromFormat PyUnicode_FromFormat
+#else
+#  define SWIG_Python_str_FromFormat PyString_FromFormat
+#endif
+
+
+/* Warning: This function will allocate a new string in Python 3,
+ * so please call SWIG_Python_str_DelForPy3(x) to free the space.
+ */
+SWIGINTERN char*
+SWIG_Python_str_AsChar(PyObject *str)
+{
+#if PY_VERSION_HEX >= 0x03000000
+  char *cstr;
+  char *newstr;
+  Py_ssize_t len;
+  str = PyUnicode_AsUTF8String(str);
+  PyBytes_AsStringAndSize(str, &cstr, &len);
+  newstr = (char *) malloc(len+1);
+  memcpy(newstr, cstr, len+1);
+  Py_XDECREF(str);
+  return newstr;
+#else
+  return PyString_AsString(str);
+#endif
+}
+
+#if PY_VERSION_HEX >= 0x03000000
+#  define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
+#else
+#  define SWIG_Python_str_DelForPy3(x) 
+#endif
+
+
+SWIGINTERN PyObject*
+SWIG_Python_str_FromChar(const char *c)
+{
+#if PY_VERSION_HEX >= 0x03000000
+  return PyUnicode_FromString(c); 
+#else
+  return PyString_FromString(c);
+#endif
+}
+
+/* Add PyOS_snprintf for old Pythons */
+#if PY_VERSION_HEX < 0x02020000
+# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
+#  define PyOS_snprintf _snprintf
+# else
+#  define PyOS_snprintf snprintf
+# endif
+#endif
+
+/* A crude PyString_FromFormat implementation for old Pythons */
+#if PY_VERSION_HEX < 0x02020000
+
+#ifndef SWIG_PYBUFFER_SIZE
+# define SWIG_PYBUFFER_SIZE 1024
+#endif
+
+static PyObject *
+PyString_FromFormat(const char *fmt, ...) {
+  va_list ap;
+  char buf[SWIG_PYBUFFER_SIZE * 2];
+  int res;
+  va_start(ap, fmt);
+  res = vsnprintf(buf, sizeof(buf), fmt, ap);
+  va_end(ap);
+  return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
+}
+#endif
+
+#ifndef PyObject_DEL
+# define PyObject_DEL PyObject_Del
+#endif
+
+/* A crude PyExc_StopIteration exception for old Pythons */
+#if PY_VERSION_HEX < 0x02020000
+# ifndef PyExc_StopIteration
+#  define PyExc_StopIteration PyExc_RuntimeError
+# endif
+# ifndef PyObject_GenericGetAttr
+#  define PyObject_GenericGetAttr 0
+# endif
+#endif
+
+/* Py_NotImplemented is defined in 2.1 and up. */
+#if PY_VERSION_HEX < 0x02010000
+# ifndef Py_NotImplemented
+#  define Py_NotImplemented PyExc_RuntimeError
+# endif
+#endif
+
+/* A crude PyString_AsStringAndSize implementation for old Pythons */
+#if PY_VERSION_HEX < 0x02010000
+# ifndef PyString_AsStringAndSize
+#  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
+# endif
+#endif
+
+/* PySequence_Size for old Pythons */
+#if PY_VERSION_HEX < 0x02000000
+# ifndef PySequence_Size
+#  define PySequence_Size PySequence_Length
+# endif
+#endif
+
+/* PyBool_FromLong for old Pythons */
+#if PY_VERSION_HEX < 0x02030000
+static
+PyObject *PyBool_FromLong(long ok)
+{
+  PyObject *result = ok ? Py_True : Py_False;
+  Py_INCREF(result);
+  return result;
+}
+#endif
+
+/* Py_ssize_t for old Pythons */
+/* This code is as recommended by: */
+/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
+#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
+typedef int Py_ssize_t;
+# define PY_SSIZE_T_MAX INT_MAX
+# define PY_SSIZE_T_MIN INT_MIN
+typedef inquiry lenfunc;
+typedef intargfunc ssizeargfunc;
+typedef intintargfunc ssizessizeargfunc;
+typedef intobjargproc ssizeobjargproc;
+typedef intintobjargproc ssizessizeobjargproc;
+typedef getreadbufferproc readbufferproc;
+typedef getwritebufferproc writebufferproc;
+typedef getsegcountproc segcountproc;
+typedef getcharbufferproc charbufferproc;
+static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
+{
+  long result = 0;
+  PyObject *i = PyNumber_Int(x);
+  if (i) {
+    result = PyInt_AsLong(i);
+    Py_DECREF(i);
+  }
+  return result;
+}
+#endif
+
+#if PY_VERSION_HEX < 0x02050000
+#define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
+#endif
+
+#if PY_VERSION_HEX < 0x02040000
+#define Py_VISIT(op)				\
+  do { 						\
+    if (op) {					\
+      int vret = visit((op), arg);		\
+      if (vret)					\
+        return vret;				\
+    }						\
+  } while (0)
+#endif
+
+#if PY_VERSION_HEX < 0x02030000
+typedef struct {
+  PyTypeObject type;
+  PyNumberMethods as_number;
+  PyMappingMethods as_mapping;
+  PySequenceMethods as_sequence;
+  PyBufferProcs as_buffer;
+  PyObject *name, *slots;
+} PyHeapTypeObject;
+#endif
+
+#if PY_VERSION_HEX < 0x02030000
+typedef destructor freefunc;
+#endif
+
+#if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
+     (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
+     (PY_MAJOR_VERSION > 3))
+# define SWIGPY_USE_CAPSULE
+# define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
+#endif
+
+#if PY_VERSION_HEX < 0x03020000
+#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
+#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
+#define Py_hash_t long
+#endif
diff --git a/share/swig/3.0.12/python/pyinit.swg b/share/swig/3.0.12/python/pyinit.swg
new file mode 100644
index 0000000..2cc5828
--- /dev/null
+++ b/share/swig/3.0.12/python/pyinit.swg
@@ -0,0 +1,457 @@
+/* ------------------------------------------------------------
+ * The start of the Python initialization function 
+ * ------------------------------------------------------------ */
+
+%insert(init) "swiginit.swg"
+
+#if defined(SWIGPYTHON_BUILTIN)
+%fragment("<stddef.h>"); // For offsetof
+#endif
+
+%init %{
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Python-specific SWIG API */
+#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
+#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
+#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
+ 
+/* -----------------------------------------------------------------------------
+ * global variable support code.
+ * ----------------------------------------------------------------------------- */
+ 
+typedef struct swig_globalvar {   
+  char       *name;                  /* Name of global variable */
+  PyObject *(*get_attr)(void);       /* Return the current value */
+  int       (*set_attr)(PyObject *); /* Set the value */
+  struct swig_globalvar *next;
+} swig_globalvar;
+
+typedef struct swig_varlinkobject {
+  PyObject_HEAD
+  swig_globalvar *vars;
+} swig_varlinkobject;
+
+SWIGINTERN PyObject *
+swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
+#if PY_VERSION_HEX >= 0x03000000
+  return PyUnicode_InternFromString("<Swig global variables>");
+#else
+  return PyString_FromString("<Swig global variables>");
+#endif
+}
+
+SWIGINTERN PyObject *
+swig_varlink_str(swig_varlinkobject *v) {
+#if PY_VERSION_HEX >= 0x03000000
+  PyObject *str = PyUnicode_InternFromString("(");
+  PyObject *tail;
+  PyObject *joined;
+  swig_globalvar *var;
+  for (var = v->vars; var; var=var->next) {
+    tail = PyUnicode_FromString(var->name);
+    joined = PyUnicode_Concat(str, tail);
+    Py_DecRef(str);
+    Py_DecRef(tail);
+    str = joined;
+    if (var->next) {
+        tail = PyUnicode_InternFromString(", ");
+        joined = PyUnicode_Concat(str, tail);
+        Py_DecRef(str);
+        Py_DecRef(tail);
+        str = joined;
+    }
+  }
+  tail = PyUnicode_InternFromString(")");
+  joined = PyUnicode_Concat(str, tail);
+  Py_DecRef(str);
+  Py_DecRef(tail);
+  str = joined;
+#else
+  PyObject *str = PyString_FromString("(");
+  swig_globalvar *var;
+  for (var = v->vars; var; var=var->next) {
+    PyString_ConcatAndDel(&str,PyString_FromString(var->name));
+    if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
+  }
+  PyString_ConcatAndDel(&str,PyString_FromString(")"));
+#endif
+  return str;
+}
+
+SWIGINTERN int
+swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
+  char *tmp;
+  PyObject *str = swig_varlink_str(v);
+  fprintf(fp,"Swig global variables ");
+  fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
+  SWIG_Python_str_DelForPy3(tmp);
+  Py_DECREF(str);
+  return 0;
+}
+
+SWIGINTERN void
+swig_varlink_dealloc(swig_varlinkobject *v) {
+  swig_globalvar *var = v->vars;
+  while (var) {
+    swig_globalvar *n = var->next;
+    free(var->name);
+    free(var);
+    var = n;
+  }
+}
+
+SWIGINTERN PyObject *
+swig_varlink_getattr(swig_varlinkobject *v, char *n) {
+  PyObject *res = NULL;
+  swig_globalvar *var = v->vars;
+  while (var) {
+    if (strcmp(var->name,n) == 0) {
+      res = (*var->get_attr)();
+      break;
+    }
+    var = var->next;
+  }
+  if (res == NULL && !PyErr_Occurred()) {
+    PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
+  }
+  return res;
+}
+
+SWIGINTERN int
+swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
+  int res = 1;
+  swig_globalvar *var = v->vars;
+  while (var) {
+    if (strcmp(var->name,n) == 0) {
+      res = (*var->set_attr)(p);
+      break;
+    }
+    var = var->next;
+  }
+  if (res == 1 && !PyErr_Occurred()) {
+    PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
+  }
+  return res;
+}
+
+SWIGINTERN PyTypeObject*
+swig_varlink_type(void) {
+  static char varlink__doc__[] = "Swig var link object";
+  static PyTypeObject varlink_type;
+  static int type_init = 0;
+  if (!type_init) {
+    const PyTypeObject tmp = {
+#if PY_VERSION_HEX >= 0x03000000
+      PyVarObject_HEAD_INIT(NULL, 0)
+#else
+      PyObject_HEAD_INIT(NULL)
+      0,                                  /* ob_size */
+#endif
+      (char *)"swigvarlink",              /* tp_name */
+      sizeof(swig_varlinkobject),         /* tp_basicsize */
+      0,                                  /* tp_itemsize */
+      (destructor) swig_varlink_dealloc,  /* tp_dealloc */
+      (printfunc) swig_varlink_print,     /* tp_print */
+      (getattrfunc) swig_varlink_getattr, /* tp_getattr */
+      (setattrfunc) swig_varlink_setattr, /* tp_setattr */
+      0,                                  /* tp_compare */
+      (reprfunc) swig_varlink_repr,       /* tp_repr */
+      0,                                  /* tp_as_number */
+      0,                                  /* tp_as_sequence */
+      0,                                  /* tp_as_mapping */
+      0,                                  /* tp_hash */
+      0,                                  /* tp_call */
+      (reprfunc) swig_varlink_str,        /* tp_str */
+      0,                                  /* tp_getattro */
+      0,                                  /* tp_setattro */
+      0,                                  /* tp_as_buffer */
+      0,                                  /* tp_flags */
+      varlink__doc__,                     /* tp_doc */
+      0,                                  /* tp_traverse */
+      0,                                  /* tp_clear */
+      0,                                  /* tp_richcompare */
+      0,                                  /* tp_weaklistoffset */
+#if PY_VERSION_HEX >= 0x02020000
+      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
+#endif
+#if PY_VERSION_HEX >= 0x02030000
+      0,                                  /* tp_del */
+#endif
+#if PY_VERSION_HEX >= 0x02060000
+      0,                                  /* tp_version_tag */
+#endif
+#if PY_VERSION_HEX >= 0x03040000
+      0,                                  /* tp_finalize */
+#endif
+#ifdef COUNT_ALLOCS
+      0,                                  /* tp_allocs */
+      0,                                  /* tp_frees */
+      0,                                  /* tp_maxalloc */
+#if PY_VERSION_HEX >= 0x02050000
+      0,                                  /* tp_prev */
+#endif
+      0                                   /* tp_next */
+#endif
+    };
+    varlink_type = tmp;
+    type_init = 1;
+#if PY_VERSION_HEX < 0x02020000
+    varlink_type.ob_type = &PyType_Type;
+#else
+    if (PyType_Ready(&varlink_type) < 0)
+      return NULL;
+#endif
+  }
+  return &varlink_type;
+}
+
+/* Create a variable linking object for use later */
+SWIGINTERN PyObject *
+SWIG_Python_newvarlink(void) {
+  swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
+  if (result) {
+    result->vars = 0;
+  }
+  return ((PyObject*) result);
+}
+
+SWIGINTERN void 
+SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
+  swig_varlinkobject *v = (swig_varlinkobject *) p;
+  swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
+  if (gv) {
+    size_t size = strlen(name)+1;
+    gv->name = (char *)malloc(size);
+    if (gv->name) {
+      strncpy(gv->name,name,size);
+      gv->get_attr = get_attr;
+      gv->set_attr = set_attr;
+      gv->next = v->vars;
+    }
+  }
+  v->vars = gv;
+}
+
+SWIGINTERN PyObject *
+SWIG_globals(void) {
+  static PyObject *_SWIG_globals = 0; 
+  if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();  
+  return _SWIG_globals;
+}
+
+/* -----------------------------------------------------------------------------
+ * constants/methods manipulation
+ * ----------------------------------------------------------------------------- */
+
+/* Install Constants */
+SWIGINTERN void
+SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
+  PyObject *obj = 0;
+  size_t i;
+  for (i = 0; constants[i].type; ++i) {
+    switch(constants[i].type) {
+    case SWIG_PY_POINTER:
+      obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
+      break;
+    case SWIG_PY_BINARY:
+      obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
+      break;
+    default:
+      obj = 0;
+      break;
+    }
+    if (obj) {
+      PyDict_SetItemString(d, constants[i].name, obj);
+      Py_DECREF(obj);
+    }
+  }
+}
+
+/* -----------------------------------------------------------------------------*/
+/* Fix SwigMethods to carry the callback ptrs when needed */
+/* -----------------------------------------------------------------------------*/
+
+SWIGINTERN void
+SWIG_Python_FixMethods(PyMethodDef *methods,
+		       swig_const_info *const_table,
+		       swig_type_info **types,
+		       swig_type_info **types_initial) {
+  size_t i;
+  for (i = 0; methods[i].ml_name; ++i) {
+    const char *c = methods[i].ml_doc;
+    if (!c) continue;
+    c = strstr(c, "swig_ptr: ");
+    if (c) {
+      int j;
+      swig_const_info *ci = 0;
+      const char *name = c + 10;
+      for (j = 0; const_table[j].type; ++j) {
+	if (strncmp(const_table[j].name, name, 
+		    strlen(const_table[j].name)) == 0) {
+	  ci = &(const_table[j]);
+	  break;
+	}
+      }
+      if (ci) {
+	void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
+	if (ptr) {
+	  size_t shift = (ci->ptype) - types;
+	  swig_type_info *ty = types_initial[shift];
+	  size_t ldoc = (c - methods[i].ml_doc);
+	  size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
+	  char *ndoc = (char*)malloc(ldoc + lptr + 10);
+	  if (ndoc) {
+	    char *buff = ndoc;
+	    strncpy(buff, methods[i].ml_doc, ldoc);
+	    buff += ldoc;
+	    strncpy(buff, "swig_ptr: ", 10);
+	    buff += 10;
+	    SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
+	    methods[i].ml_doc = ndoc;
+	  }
+	}
+      }
+    }
+  }
+} 
+
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------*
+ *  Partial Init method
+ * -----------------------------------------------------------------------------*/
+
+#ifdef __cplusplus
+extern "C"
+#endif
+
+SWIGEXPORT 
+#if PY_VERSION_HEX >= 0x03000000
+  PyObject*
+#else
+  void
+#endif
+SWIG_init(void) {
+  PyObject *m, *d, *md;
+#if PY_VERSION_HEX >= 0x03000000
+  static struct PyModuleDef SWIG_module = {
+# if PY_VERSION_HEX >= 0x03020000
+    PyModuleDef_HEAD_INIT,
+# else
+    {
+      PyObject_HEAD_INIT(NULL)
+      NULL, /* m_init */
+      0,    /* m_index */
+      NULL, /* m_copy */
+    },
+# endif
+    (char *) SWIG_name,
+    NULL,
+    -1,
+    SwigMethods,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+  };
+#endif
+
+#if defined(SWIGPYTHON_BUILTIN)
+  static SwigPyClientData SwigPyObject_clientdata = {0, 0, 0, 0, 0, 0, 0};
+  static PyGetSetDef this_getset_def = {
+    (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
+  };
+  static SwigPyGetSet thisown_getset_closure = {
+    (PyCFunction) SwigPyObject_own,
+    (PyCFunction) SwigPyObject_own
+  };
+  static PyGetSetDef thisown_getset_def = {
+    (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
+  };
+  PyTypeObject *builtin_pytype;
+  int builtin_base_count;
+  swig_type_info *builtin_basetype;
+  PyObject *tuple;
+  PyGetSetDescrObject *static_getset;
+  PyTypeObject *metatype;
+  PyTypeObject *swigpyobject;
+  SwigPyClientData *cd;
+  PyObject *public_interface, *public_symbol;
+  PyObject *this_descr;
+  PyObject *thisown_descr;
+  PyObject *self = 0;
+  int i;
+
+  (void)builtin_pytype;
+  (void)builtin_base_count;
+  (void)builtin_basetype;
+  (void)tuple;
+  (void)static_getset;
+  (void)self;
+
+  /* Metaclass is used to implement static member variables */
+  metatype = SwigPyObjectType();
+  assert(metatype);
+#endif
+
+  /* Fix SwigMethods to carry the callback ptrs when needed */
+  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
+
+#if PY_VERSION_HEX >= 0x03000000
+  m = PyModule_Create(&SWIG_module);
+#else
+  m = Py_InitModule((char *) SWIG_name, SwigMethods);
+#endif
+
+  md = d = PyModule_GetDict(m);
+  (void)md;
+
+  SWIG_InitializeModule(0);
+
+#ifdef SWIGPYTHON_BUILTIN
+  swigpyobject = SwigPyObject_TypeOnce();
+
+  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
+  assert(SwigPyObject_stype);
+  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
+  if (!cd) {
+    SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
+    SwigPyObject_clientdata.pytype = swigpyobject;
+  } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
+    PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
+# if PY_VERSION_HEX >= 0x03000000
+    return NULL;
+# else
+    return;
+# endif
+  }
+
+  /* All objects have a 'this' attribute */
+  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
+  (void)this_descr;
+
+  /* All objects have a 'thisown' attribute */
+  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
+  (void)thisown_descr;
+
+  public_interface = PyList_New(0);
+  public_symbol = 0;
+  (void)public_symbol;
+
+  PyDict_SetItemString(md, "__all__", public_interface);
+  Py_DECREF(public_interface);
+  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
+    SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
+  for (i = 0; swig_const_table[i].name != 0; ++i)
+    SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
+#endif
+
+  SWIG_InstallConstants(d,swig_const_table);
+%}
+
diff --git a/share/swig/3.0.12/python/pyiterators.swg b/share/swig/3.0.12/python/pyiterators.swg
new file mode 100644
index 0000000..8fbb312
--- /dev/null
+++ b/share/swig/3.0.12/python/pyiterators.swg
@@ -0,0 +1,405 @@
+/* -----------------------------------------------------------------------------
+ * pyiterators.swg
+ *
+ * Implement a python 'output' iterator for Python 2.2 or higher.
+ *
+ * Users can derive form the SwigPyIterator to implement their
+ * own iterators. As an example (real one since we use it for STL/STD
+ * containers), the template SwigPyIterator_T does the
+ * implementation for generic C++ iterators.
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+
+%fragment("SwigPyIterator","header",fragment="<stddef.h>") {
+namespace swig {
+  struct stop_iteration {
+  };
+
+  struct SwigPyIterator {
+  private:
+    SwigPtr_PyObject _seq;
+
+  protected:
+    SwigPyIterator(PyObject *seq) : _seq(seq)
+    {
+    }
+      
+  public:
+    virtual ~SwigPyIterator() {}
+
+    // Access iterator method, required by Python
+    virtual PyObject *value() const = 0;
+
+    // Forward iterator method, required by Python
+    virtual SwigPyIterator *incr(size_t n = 1) = 0;
+    
+    // Backward iterator method, very common in C++, but not required in Python
+    virtual SwigPyIterator *decr(size_t /*n*/ = 1)
+    {
+      throw stop_iteration();
+    }
+
+    // Random access iterator methods, but not required in Python
+    virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const
+    {
+      throw std::invalid_argument("operation not supported");
+    }
+
+    virtual bool equal (const SwigPyIterator &/*x*/) const
+    {
+      throw std::invalid_argument("operation not supported");
+    }
+    
+    // C++ common/needed methods
+    virtual SwigPyIterator *copy() const = 0;
+
+    PyObject *next()     
+    {
+      SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
+      PyObject *obj = value();
+      incr();       
+      SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
+      return obj;     
+    }
+
+    /* Make an alias for Python 3.x */
+    PyObject *__next__()
+    {
+      return next();
+    }
+
+    PyObject *previous()
+    {
+      SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
+      decr();
+      PyObject *obj = value();
+      SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads       
+      return obj;
+    }
+
+    SwigPyIterator *advance(ptrdiff_t n)
+    {
+      return  (n > 0) ?  incr(n) : decr(-n);
+    }
+      
+    bool operator == (const SwigPyIterator& x)  const
+    {
+      return equal(x);
+    }
+      
+    bool operator != (const SwigPyIterator& x) const
+    {
+      return ! operator==(x);
+    }
+      
+    SwigPyIterator& operator += (ptrdiff_t n)
+    {
+      return *advance(n);
+    }
+
+    SwigPyIterator& operator -= (ptrdiff_t n)
+    {
+      return *advance(-n);
+    }
+      
+    SwigPyIterator* operator + (ptrdiff_t n) const
+    {
+      return copy()->advance(n);
+    }
+
+    SwigPyIterator* operator - (ptrdiff_t n) const
+    {
+      return copy()->advance(-n);
+    }
+      
+    ptrdiff_t operator - (const SwigPyIterator& x) const
+    {
+      return x.distance(*this);
+    }
+      
+    static swig_type_info* descriptor() {
+      static int init = 0;
+      static swig_type_info* desc = 0;
+      if (!init) {
+	desc = SWIG_TypeQuery("swig::SwigPyIterator *");
+	init = 1;
+      }	
+      return desc;
+    }    
+  };
+
+%#if defined(SWIGPYTHON_BUILTIN)
+  inline PyObject* make_output_iterator_builtin (PyObject *pyself)
+  {
+    Py_INCREF(pyself);
+    return pyself;
+  }
+%#endif
+}
+}
+
+%fragment("SwigPyIterator_T","header",fragment="<stddef.h>",fragment="SwigPyIterator",fragment="StdTraits",fragment="StdIteratorTraits") {
+namespace swig {
+  template<typename OutIterator>
+  class SwigPyIterator_T :  public SwigPyIterator
+  {
+  public:
+    typedef OutIterator out_iterator;
+    typedef typename std::iterator_traits<out_iterator>::value_type value_type;    
+    typedef SwigPyIterator_T<out_iterator> self_type;
+
+    SwigPyIterator_T(out_iterator curr, PyObject *seq)
+      : SwigPyIterator(seq), current(curr)
+    {
+    }
+
+    const out_iterator& get_current() const
+    {
+      return current;
+    }
+
+    
+    bool equal (const SwigPyIterator &iter) const
+    {
+      const self_type *iters = dynamic_cast<const self_type *>(&iter);
+      if (iters) {
+	return (current == iters->get_current());
+      } else {
+	throw std::invalid_argument("bad iterator type");
+      }
+    }
+    
+    ptrdiff_t distance(const SwigPyIterator &iter) const
+    {
+      const self_type *iters = dynamic_cast<const self_type *>(&iter);
+      if (iters) {
+	return std::distance(current, iters->get_current());
+      } else {
+	throw std::invalid_argument("bad iterator type");
+      }
+    }    
+    
+  protected:
+    out_iterator current;
+  };
+  
+  template <class ValueType>
+  struct from_oper 
+  {
+    typedef const ValueType& argument_type;
+    typedef PyObject *result_type;
+    result_type operator()(argument_type v) const
+    {
+      return swig::from(v);
+    }
+  };
+
+  template<typename OutIterator, 
+	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
+	   typename FromOper = from_oper<ValueType> >
+  class SwigPyIteratorOpen_T :  public SwigPyIterator_T<OutIterator>
+  {
+  public:
+    FromOper from;
+    typedef OutIterator out_iterator;
+    typedef ValueType value_type;
+    typedef SwigPyIterator_T<out_iterator>  base;
+    typedef SwigPyIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
+    
+    SwigPyIteratorOpen_T(out_iterator curr, PyObject *seq)
+      : SwigPyIterator_T<OutIterator>(curr, seq)
+    {
+    }
+    
+    PyObject *value() const {
+      return from(static_cast<const value_type&>(*(base::current)));
+    }
+    
+    SwigPyIterator *copy() const
+    {
+      return new self_type(*this);
+    }
+
+    SwigPyIterator *incr(size_t n = 1)
+    {
+      while (n--) {
+	++base::current;
+      }
+      return this;
+    }
+
+    SwigPyIterator *decr(size_t n = 1)
+    {
+      while (n--) {
+	--base::current;
+      }
+      return this;
+    }
+  };
+
+  template<typename OutIterator, 
+	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
+	   typename FromOper = from_oper<ValueType> >
+  class SwigPyIteratorClosed_T :  public SwigPyIterator_T<OutIterator>
+  {
+  public:
+    FromOper from;
+    typedef OutIterator out_iterator;
+    typedef ValueType value_type;
+    typedef SwigPyIterator_T<out_iterator>  base;    
+    typedef SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
+    
+    SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
+      : SwigPyIterator_T<OutIterator>(curr, seq), begin(first), end(last)
+    {
+    }
+    
+    PyObject *value() const {
+      if (base::current == end) {
+	throw stop_iteration();
+      } else {
+	return from(static_cast<const value_type&>(*(base::current)));
+      }
+    }
+    
+    SwigPyIterator *copy() const
+    {
+      return new self_type(*this);
+    }
+
+    SwigPyIterator *incr(size_t n = 1)
+    {
+      while (n--) {
+	if (base::current == end) {
+	  throw stop_iteration();
+	} else {
+	  ++base::current;
+	}
+      }
+      return this;
+    }
+
+    SwigPyIterator *decr(size_t n = 1)
+    {
+      while (n--) {
+	if (base::current == begin) {
+	  throw stop_iteration();
+	} else {
+	  --base::current;
+	}
+      }
+      return this;
+    }
+
+  private:
+    out_iterator begin;
+    out_iterator end;
+  };
+
+  template<typename OutIter>
+  inline SwigPyIterator*
+  make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
+  {
+    return new SwigPyIteratorClosed_T<OutIter>(current, begin, end, seq);
+  }
+
+  template<typename OutIter>
+  inline SwigPyIterator*
+  make_output_iterator(const OutIter& current, PyObject *seq = 0)
+  {
+    return new SwigPyIteratorOpen_T<OutIter>(current, seq);
+  }
+
+}
+}
+
+
+%fragment("SwigPyIterator");
+namespace swig 
+{
+  /*
+    Throw a StopIteration exception
+  */
+  %ignore stop_iteration;
+  struct stop_iteration {};
+  
+  %typemap(throws) stop_iteration {
+    (void)$1;
+    SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+    SWIG_fail;
+  }
+
+  /* 
+     Mark methods that return new objects
+  */
+  %newobject SwigPyIterator::copy;
+  %newobject SwigPyIterator::operator + (ptrdiff_t n) const;
+  %newobject SwigPyIterator::operator - (ptrdiff_t n) const;
+
+  %nodirector SwigPyIterator;
+
+#if defined(SWIGPYTHON_BUILTIN)
+  %feature("python:tp_iter") SwigPyIterator "&swig::make_output_iterator_builtin";
+  %feature("python:slot", "tp_iternext", functype="iternextfunc") SwigPyIterator::__next__;
+#else
+  %extend SwigPyIterator {
+  %pythoncode %{def __iter__(self):
+    return self%}
+  }
+#endif
+
+  %catches(swig::stop_iteration) SwigPyIterator::value() const;
+  %catches(swig::stop_iteration) SwigPyIterator::incr(size_t n = 1);
+  %catches(swig::stop_iteration) SwigPyIterator::decr(size_t n = 1);
+  %catches(std::invalid_argument) SwigPyIterator::distance(const SwigPyIterator &x) const;
+  %catches(std::invalid_argument) SwigPyIterator::equal (const SwigPyIterator &x) const;
+  %catches(swig::stop_iteration) SwigPyIterator::__next__();
+  %catches(swig::stop_iteration) SwigPyIterator::next();
+  %catches(swig::stop_iteration) SwigPyIterator::previous();
+  %catches(swig::stop_iteration) SwigPyIterator::advance(ptrdiff_t n);
+  %catches(swig::stop_iteration) SwigPyIterator::operator += (ptrdiff_t n);
+  %catches(swig::stop_iteration) SwigPyIterator::operator -= (ptrdiff_t n);
+  %catches(swig::stop_iteration) SwigPyIterator::operator + (ptrdiff_t n) const;
+  %catches(swig::stop_iteration) SwigPyIterator::operator - (ptrdiff_t n) const;
+
+  struct SwigPyIterator
+  {
+  protected:
+    SwigPyIterator(PyObject *seq);
+
+  public:
+    virtual ~SwigPyIterator();
+
+    // Access iterator method, required by Python
+    virtual PyObject *value() const = 0;
+
+    // Forward iterator method, required by Python
+    virtual SwigPyIterator *incr(size_t n = 1) = 0;
+    
+    // Backward iterator method, very common in C++, but not required in Python
+    virtual SwigPyIterator *decr(size_t n = 1);
+
+    // Random access iterator methods, but not required in Python
+    virtual ptrdiff_t distance(const SwigPyIterator &x) const;
+
+    virtual bool equal (const SwigPyIterator &x) const;
+    
+    // C++ common/needed methods
+    virtual SwigPyIterator *copy() const = 0;
+
+    PyObject *next();
+    PyObject *__next__();
+    PyObject *previous();
+    SwigPyIterator *advance(ptrdiff_t n);
+
+    bool operator == (const SwigPyIterator& x)  const;
+    bool operator != (const SwigPyIterator& x) const;
+    SwigPyIterator& operator += (ptrdiff_t n);
+    SwigPyIterator& operator -= (ptrdiff_t n);
+    SwigPyIterator* operator + (ptrdiff_t n) const;
+    SwigPyIterator* operator - (ptrdiff_t n) const;
+    ptrdiff_t operator - (const SwigPyIterator& x) const;
+  };
+}
+
diff --git a/share/swig/2.0.11/python/pymacros.swg b/share/swig/3.0.12/python/pymacros.swg
index ab7bace..ab7bace 100644
--- a/share/swig/2.0.11/python/pymacros.swg
+++ b/share/swig/3.0.12/python/pymacros.swg
diff --git a/share/swig/2.0.11/python/pyname_compat.i b/share/swig/3.0.12/python/pyname_compat.i
index 96af343..96af343 100644
--- a/share/swig/2.0.11/python/pyname_compat.i
+++ b/share/swig/3.0.12/python/pyname_compat.i
diff --git a/share/swig/3.0.12/python/pyopers.swg b/share/swig/3.0.12/python/pyopers.swg
new file mode 100644
index 0000000..fd2fcc5
--- /dev/null
+++ b/share/swig/3.0.12/python/pyopers.swg
@@ -0,0 +1,264 @@
+/* ------------------------------------------------------------
+ * Overloaded operator support
+
+ The directives in this file apply whether or not you use the
+ -builtin option to SWIG, but operator overloads are particularly
+ attractive when using -builtin, because they are much faster
+ than named methods.
+
+ If you're using the -builtin option to SWIG, and you want to define
+ python operator overloads beyond the defaults defined in this file,
+ here's what you need to know:
+
+ There are two ways to define a python slot function: dispatch to a
+ statically defined function; or dispatch to a method defined on the
+ operand.
+
+ To dispatch to a statically defined function, use %feature("python:<slot>"),
+ where <slot> is the name of a field in a PyTypeObject, PyNumberMethods,
+ PyMappingMethods, PySequenceMethods, or PyBufferProcs.  For example:
+
+   %feature("python:tp_hash") MyClass "myHashFunc";
+
+   class MyClass {
+     public:
+       ...
+   };
+
+   %{
+     // Note: Py_hash_t was introduced in Python 3.2
+     static Py_hash_t myHashFunc(PyObject *pyobj) {
+       MyClass *cobj;
+       // Convert pyobj to cobj
+       return (cobj->field1 * (cobj->field2 << 7));
+     }
+   %}
+
+ NOTE: It is the responsibility of the programmer (that's you) to ensure
+ that a statically defined slot function has the correct signature.
+
+ If, instead, you want to dispatch to an instance method, you can
+ use %feature("python:slot").  For example:
+
+   %feature("python:slot", "tp_hash", functype="hashfunc") MyClass::myHashFunc;
+
+   class MyClass {
+     public:
+       Py_hash_t myHashFunc () const;
+       ...
+   };
+
+ NOTE: Some python slots use a method signature which does not
+ match the signature of SWIG-wrapped methods.  For those slots,
+ SWIG will automatically generate a "closure" function to re-marshall
+ the arguments before dispatching to the wrapped method.  Setting
+ the "functype" attribute of the feature enables SWIG to generate
+ a correct closure function.
+
+ --------------------------------------------------------------
+
+ The tp_richcompare slot is a special case: SWIG automatically generates
+ a rich compare function for all wrapped types.  If a type defines C++
+ operator overloads for comparison (operator==, operator<, etc.), they
+ will be called from the generated rich compare function.  If you
+ want to explicitly choose a method to handle a certain comparison
+ operation, you may use a different feature, %feature("python:compare")
+ like this:
+
+   %feature("python:compare", "Py_LT") MyClass::lessThan;
+
+   class MyClass {
+     public:
+       bool lessThan(const MyClass& other) const;
+       ...
+   };
+   
+ ... where "Py_LT" is one of the rich comparison opcodes defined in the
+ python header file object.h.
+
+ If there's no method defined to handle a particular comparison operation,
+ the default behavior is to compare pointer values of the wrapped
+ C++ objects.
+
+ --------------------------------------------------------------
+
+
+ For more information about python slots, including their names and
+ signatures, you may refer to the python documentation :
+
+   http://docs.python.org/c-api/typeobj.html
+
+ * ------------------------------------------------------------ */
+
+
+#ifdef __cplusplus
+
+#if defined(SWIGPYTHON_BUILTIN)
+#define %pybinoperator(pyname,oper,functp,slt) %rename(pyname) oper; %pythonmaybecall oper; %feature("python:slot", #slt, functype=#functp) oper; %feature("python:slot", #slt, functype=#functp) pyname;
+#define %pycompare(pyname,oper,comptype) %rename(pyname) oper; %pythonmaybecall oper; %feature("python:compare", #comptype) oper; %feature("python:compare", #comptype) pyname;
+#else
+#define %pybinoperator(pyname,oper,functp,slt) %rename(pyname) oper; %pythonmaybecall oper
+#define %pycompare(pyname,oper,comptype) %pybinoperator(pyname,oper,,comptype)
+#endif
+
+%pybinoperator(__add__,      *::operator+,		binaryfunc, nb_add);
+%pybinoperator(__pos__,      *::operator+(),		unaryfunc, nb_positive);
+%pybinoperator(__pos__,      *::operator+() const,	unaryfunc, nb_positive);
+%pybinoperator(__sub__,      *::operator-,		binaryfunc, nb_subtract);
+%pybinoperator(__neg__,      *::operator-(),		unaryfunc, nb_negative);
+%pybinoperator(__neg__,      *::operator-() const,	unaryfunc, nb_negative);
+%pybinoperator(__mul__,      *::operator*,		binaryfunc, nb_multiply);
+%pybinoperator(__mod__,      *::operator%,		binaryfunc, nb_remainder);
+%pybinoperator(__lshift__,   *::operator<<,		binaryfunc, nb_lshift);
+%pybinoperator(__rshift__,   *::operator>>,		binaryfunc, nb_rshift);
+%pybinoperator(__and__,      *::operator&,		binaryfunc, nb_and);
+%pybinoperator(__or__,       *::operator|,		binaryfunc, nb_or);
+%pybinoperator(__xor__,      *::operator^,		binaryfunc, nb_xor);
+%pycompare(__lt__,           *::operator<,		Py_LT);
+%pycompare(__le__,           *::operator<=,		Py_LE);
+%pycompare(__gt__,           *::operator>,		Py_GT);
+%pycompare(__ge__,           *::operator>=,		Py_GE);
+%pycompare(__eq__,           *::operator==,		Py_EQ);
+%pycompare(__ne__,           *::operator!=,		Py_NE);
+
+/* Special cases */
+%rename(__invert__)     *::operator~;
+%feature("python:slot", "nb_invert", functype="unaryfunc") *::operator~;
+%rename(__call__)       *::operator();
+%feature("python:slot", "tp_call", functype="ternarycallfunc") *::operator();
+
+#if defined(SWIGPYTHON_BUILTIN)
+%pybinoperator(__nonzero__,   *::operator bool,		inquiry, nb_nonzero);
+%pybinoperator(__truediv__,   *::operator/    ,		binaryfunc, nb_divide);
+#else
+%feature("shadow")      *::operator bool %{
+def __nonzero__(self):
+    return $action(self)
+__bool__ = __nonzero__
+%};
+%rename(__nonzero__)    *::operator bool;
+%feature("shadow")      *::operator/ %{
+def __truediv__(self, *args):
+    return $action(self, *args)
+__div__ = __truediv__
+%};
+%rename(__truediv__)    *::operator/;
+%pythonmaybecall        *::operator/;
+#endif
+
+/* Ignored operators */
+%ignoreoperator(LNOT)       operator!;
+%ignoreoperator(LAND)       operator&&;
+%ignoreoperator(LOR)        operator||;
+%ignoreoperator(EQ)         *::operator=;
+%ignoreoperator(PLUSPLUS)   *::operator++;
+%ignoreoperator(MINUSMINUS) *::operator--;
+%ignoreoperator(ARROWSTAR)  *::operator->*;
+%ignoreoperator(INDEX)      *::operator[];
+
+/*
+  Inplace operator declarations.
+
+  They translate the inplace C++ operators (+=, -=, ...)  into the
+  corresponding python equivalents(__iadd__,__isub__), etc,
+  disabling the ownership of the input 'this' pointer, and assigning
+  it to the returning object:  
+
+     %feature("del") *::Operator; // disables ownership by generating SWIG_POINTER_DISOWN
+     %feature("new") *::Operator; // claims ownership by generating SWIG_POINTER_OWN
+  
+  This makes the most common case safe, ie:
+
+     A&  A::operator+=(int i) { ...; return *this; }
+    ^^^^                                    ^^^^^^
+
+  will work fine, even when the resulting python object shares the
+  'this' pointer with the input one. The input object is usually
+  deleted after the operation, including the shared 'this' pointer,
+  producing 'strange' seg faults, as reported by Lucriz
+  (lucriz@sitilandia.it).
+
+  If you have an interface that already takes care of that, ie, you
+  already are using inplace operators and you are not getting
+  seg. faults, with the new scheme you could end with 'free' elements
+  that never get deleted (maybe, not sure, it depends). But if that is
+  the case, you could recover the old behaviour using
+
+     %feature("del","0") A::operator+=;
+     %feature("new","0") A::operator+=;
+
+  which recovers the old behaviour for the class 'A', or if you are
+  100% sure your entire system works fine in the old way, use:
+
+    %feature("del","") *::operator+=;
+    %feature("new","") *::operator+=;
+
+  The default behaviour assumes that the 'this' pointer's memory is
+  already owned by the SWIG object; it relinquishes ownership then
+  takes it back. This may not be the case though as the SWIG object
+  might be owned by memory managed elsewhere, eg after calling a
+  function that returns a C++ reference. In such case you will need
+  to use the features above to recover the old behaviour too.
+*/
+
+#if defined(SWIGPYTHON_BUILTIN)
+#define %pyinplaceoper(SwigPyOper, Oper, functp, slt) %delobject Oper; %newobject Oper; %feature("python:slot", #slt, functype=#functp) Oper; %rename(SwigPyOper) Oper
+#else
+#define %pyinplaceoper(SwigPyOper, Oper, functp, slt) %delobject Oper; %newobject Oper; %rename(SwigPyOper) Oper
+#endif
+
+%pyinplaceoper(__iadd__   , *::operator +=,	binaryfunc, nb_inplace_add);
+%pyinplaceoper(__isub__   , *::operator -=,	binaryfunc, nb_inplace_subtract);
+%pyinplaceoper(__imul__   , *::operator *=,	binaryfunc, nb_inplace_multiply);
+%pyinplaceoper(__imod__   , *::operator %=,	binaryfunc, nb_inplace_remainder);
+%pyinplaceoper(__iand__   , *::operator &=,	binaryfunc, nb_inplace_and);
+%pyinplaceoper(__ior__    , *::operator |=,	binaryfunc, nb_inplace_or);
+%pyinplaceoper(__ixor__   , *::operator ^=,	binaryfunc, nb_inplace_xor);
+%pyinplaceoper(__ilshift__, *::operator <<=,	binaryfunc, nb_inplace_lshift);
+%pyinplaceoper(__irshift__, *::operator >>=,	binaryfunc, nb_inplace_rshift);
+
+/* Special cases */
+#if defined(SWIGPYTHON_BUILTIN)
+%pyinplaceoper(__itruediv__   , *::operator /=,	binaryfunc, nb_inplace_divide);
+#else
+%delobject *::operator /=;
+%newobject *::operator /=;
+%feature("shadow")      *::operator /= %{
+def __itruediv__(self, *args):
+    return $action(self, *args)
+__idiv__ = __itruediv__
+%};
+%rename(__itruediv__)    *::operator /=;
+#endif
+
+/* Finally, in python we need to mark the binary operations to fail as
+ 'maybecall' methods */
+
+#define %pybinopermaybecall(oper) %pythonmaybecall __ ## oper ## __;  %pythonmaybecall __r ## oper ## __
+
+%pybinopermaybecall(add);
+%pybinopermaybecall(pos);
+%pybinopermaybecall(pos);
+%pybinopermaybecall(sub);
+%pybinopermaybecall(neg);
+%pybinopermaybecall(neg);
+%pybinopermaybecall(mul);
+%pybinopermaybecall(div);
+%pybinopermaybecall(truediv);
+%pybinopermaybecall(mod);
+%pybinopermaybecall(lshift);
+%pybinopermaybecall(rshift);
+%pybinopermaybecall(and);
+%pybinopermaybecall(or);
+%pybinopermaybecall(xor);
+%pybinopermaybecall(lt);
+%pybinopermaybecall(le);
+%pybinopermaybecall(gt);
+%pybinopermaybecall(ge);
+%pybinopermaybecall(eq);
+%pybinopermaybecall(ne);
+
+#endif
+
+
+
diff --git a/share/swig/3.0.12/python/pyprimtypes.swg b/share/swig/3.0.12/python/pyprimtypes.swg
new file mode 100644
index 0000000..6a01af1
--- /dev/null
+++ b/share/swig/3.0.12/python/pyprimtypes.swg
@@ -0,0 +1,353 @@
+/* ------------------------------------------------------------
+ * Primitive Types
+ * ------------------------------------------------------------ */
+
+/* boolean */
+
+%fragment(SWIG_From_frag(bool),"header") {
+SWIGINTERNINLINE PyObject*
+  SWIG_From_dec(bool)(bool value)
+{
+  return PyBool_FromLong(value ? 1 : 0);
+}
+}
+
+#ifdef SWIG_PYTHON_LEGACY_BOOL
+// Default prior to SWIG 3.0.0
+%fragment(SWIG_AsVal_frag(bool),"header",
+	  fragment=SWIG_AsVal_frag(long)) {
+SWIGINTERN int
+SWIG_AsVal_dec(bool)(PyObject *obj, bool *val)
+{
+  int r = PyObject_IsTrue(obj);
+  if (r == -1)
+    return SWIG_ERROR;
+  if (val) *val = r ? true : false;
+  return SWIG_OK;
+}
+}
+#else
+%fragment(SWIG_AsVal_frag(bool),"header",
+	  fragment=SWIG_AsVal_frag(long)) {
+SWIGINTERN int
+SWIG_AsVal_dec(bool)(PyObject *obj, bool *val)
+{
+  int r;
+  if (!PyBool_Check(obj))
+    return SWIG_ERROR;
+  r = PyObject_IsTrue(obj);
+  if (r == -1)
+    return SWIG_ERROR;
+  if (val) *val = r ? true : false;
+  return SWIG_OK;
+}
+}
+#endif
+
+/* int */
+
+%fragment(SWIG_From_frag(int),"header") {
+SWIGINTERNINLINE PyObject*
+  SWIG_From_dec(int)(int value)
+{
+  return PyInt_FromLong((long) value);
+}
+}
+
+/* unsigned int */
+
+%fragment(SWIG_From_frag(unsigned int),"header") {
+SWIGINTERNINLINE PyObject*
+  SWIG_From_dec(unsigned int)(unsigned int value)
+{
+  return PyInt_FromSize_t((size_t) value);
+}
+}
+
+/* long */
+
+%fragment(SWIG_From_frag(long),"header") {
+  %define_as(SWIG_From_dec(long),           PyInt_FromLong)
+}
+
+%fragment(SWIG_AsVal_frag(long),"header",
+	  fragment="SWIG_CanCastAsInteger") {
+SWIGINTERN int
+SWIG_AsVal_dec(long)(PyObject *obj, long* val)
+{
+%#if PY_VERSION_HEX < 0x03000000
+  if (PyInt_Check(obj)) {
+    if (val) *val = PyInt_AsLong(obj);
+    return SWIG_OK;
+  } else
+%#endif
+  if (PyLong_Check(obj)) {
+    long v = PyLong_AsLong(obj);
+    if (!PyErr_Occurred()) {
+      if (val) *val = v;
+      return SWIG_OK;
+    } else {
+      PyErr_Clear();
+      return SWIG_OverflowError;
+    }
+  }
+%#ifdef SWIG_PYTHON_CAST_MODE
+  {
+    int dispatch = 0;
+    long v = PyInt_AsLong(obj);
+    if (!PyErr_Occurred()) {
+      if (val) *val = v;
+      return SWIG_AddCast(SWIG_OK);
+    } else {
+      PyErr_Clear();
+    }
+    if (!dispatch) {
+      double d;
+      int res = SWIG_AddCast(SWIG_AsVal(double)(obj,&d));
+      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
+	if (val) *val = (long)(d);
+	return res;
+      }
+    }
+  }
+%#endif
+  return SWIG_TypeError;
+}
+}
+
+/* unsigned long */
+
+%fragment(SWIG_From_frag(unsigned long),"header",
+	  fragment=SWIG_From_frag(long)) {
+SWIGINTERNINLINE PyObject* 
+SWIG_From_dec(unsigned long)(unsigned long value)
+{
+  return (value > LONG_MAX) ?
+    PyLong_FromUnsignedLong(value) : PyInt_FromLong(%numeric_cast(value,long));
+}
+}
+
+%fragment(SWIG_AsVal_frag(unsigned long),"header",
+	  fragment="SWIG_CanCastAsInteger") {
+SWIGINTERN int
+SWIG_AsVal_dec(unsigned long)(PyObject *obj, unsigned long *val) 
+{
+%#if PY_VERSION_HEX < 0x03000000
+  if (PyInt_Check(obj)) {
+    long v = PyInt_AsLong(obj);
+    if (v >= 0) {
+      if (val) *val = v;
+      return SWIG_OK;
+    } else {
+      return SWIG_OverflowError;
+    }
+  } else
+%#endif
+  if (PyLong_Check(obj)) {
+    unsigned long v = PyLong_AsUnsignedLong(obj);
+    if (!PyErr_Occurred()) {
+      if (val) *val = v;
+      return SWIG_OK;
+    } else {
+      PyErr_Clear();
+      return SWIG_OverflowError;
+    }
+  }
+%#ifdef SWIG_PYTHON_CAST_MODE
+  {
+    int dispatch = 0;
+    unsigned long v = PyLong_AsUnsignedLong(obj);
+    if (!PyErr_Occurred()) {
+      if (val) *val = v;
+      return SWIG_AddCast(SWIG_OK);
+    } else {
+      PyErr_Clear();
+    }
+    if (!dispatch) {
+      double d;
+      int res = SWIG_AddCast(SWIG_AsVal(double)(obj,&d));
+      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
+	if (val) *val = (unsigned long)(d);
+	return res;
+      }
+    }
+  }
+%#endif
+  return SWIG_TypeError;
+}
+}
+
+/* long long */
+
+%fragment(SWIG_From_frag(long long),"header",
+	  fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERNINLINE PyObject* 
+SWIG_From_dec(long long)(long long value)
+{
+  return ((value < LONG_MIN) || (value > LONG_MAX)) ?
+    PyLong_FromLongLong(value) : PyInt_FromLong(%numeric_cast(value,long));
+}
+%#endif
+}
+
+%fragment(SWIG_AsVal_frag(long long),"header",
+	  fragment=SWIG_AsVal_frag(long),
+	  fragment="SWIG_CanCastAsInteger",
+	  fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERN int
+SWIG_AsVal_dec(long long)(PyObject *obj, long long *val)
+{
+  int res = SWIG_TypeError;
+  if (PyLong_Check(obj)) {
+    long long v = PyLong_AsLongLong(obj);
+    if (!PyErr_Occurred()) {
+      if (val) *val = v;
+      return SWIG_OK;
+    } else {
+      PyErr_Clear();
+      res = SWIG_OverflowError;
+    }
+  } else {
+    long v;
+    res = SWIG_AsVal(long)(obj,&v);
+    if (SWIG_IsOK(res)) {
+      if (val) *val = v;
+      return res;
+    }
+  }
+%#ifdef SWIG_PYTHON_CAST_MODE
+  {
+    const double mant_max = 1LL << DBL_MANT_DIG;
+    const double mant_min = -mant_max;
+    double d;
+    res = SWIG_AsVal(double)(obj,&d);
+    if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, mant_min, mant_max))
+      return SWIG_OverflowError;
+    if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
+      if (val) *val = (long long)(d);
+      return SWIG_AddCast(res);
+    }
+    res = SWIG_TypeError;
+  }
+%#endif
+  return res;
+}
+%#endif
+}
+
+/* unsigned long long */
+
+%fragment(SWIG_From_frag(unsigned long long),"header",
+	  fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERNINLINE PyObject* 
+SWIG_From_dec(unsigned long long)(unsigned long long value)
+{
+  return (value > LONG_MAX) ?
+    PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(%numeric_cast(value,long));
+}
+%#endif
+}
+
+%fragment(SWIG_AsVal_frag(unsigned long long),"header",
+	  fragment=SWIG_AsVal_frag(unsigned long),
+	  fragment="SWIG_CanCastAsInteger",
+	  fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERN int
+SWIG_AsVal_dec(unsigned long long)(PyObject *obj, unsigned long long *val)
+{
+  int res = SWIG_TypeError;
+  if (PyLong_Check(obj)) {
+    unsigned long long v = PyLong_AsUnsignedLongLong(obj);
+    if (!PyErr_Occurred()) {
+      if (val) *val = v;
+      return SWIG_OK;
+    } else {
+      PyErr_Clear();
+      res = SWIG_OverflowError;
+    }
+  } else {
+    unsigned long v;
+    res = SWIG_AsVal(unsigned long)(obj,&v);
+    if (SWIG_IsOK(res)) {
+      if (val) *val = v;
+      return res;
+    }
+  }
+%#ifdef SWIG_PYTHON_CAST_MODE
+  {
+    const double mant_max = 1LL << DBL_MANT_DIG;
+    double d;
+    res = SWIG_AsVal(double)(obj,&d);
+    if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
+      return SWIG_OverflowError;
+    if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
+      if (val) *val = (unsigned long long)(d);
+      return SWIG_AddCast(res);
+    }
+    res = SWIG_TypeError;
+  }
+%#endif
+  return res;
+}
+%#endif
+}
+
+/* double */
+
+%fragment(SWIG_From_frag(double),"header") {
+  %define_as(SWIG_From_dec(double),          PyFloat_FromDouble)
+}
+
+%fragment(SWIG_AsVal_frag(double),"header") {
+SWIGINTERN int
+SWIG_AsVal_dec(double)(PyObject *obj, double *val)
+{
+  int res = SWIG_TypeError;
+  if (PyFloat_Check(obj)) {
+    if (val) *val = PyFloat_AsDouble(obj);
+    return SWIG_OK;
+%#if PY_VERSION_HEX < 0x03000000
+  } else if (PyInt_Check(obj)) {
+    if (val) *val = (double) PyInt_AsLong(obj);
+    return SWIG_OK;
+%#endif
+  } else if (PyLong_Check(obj)) {
+    double v = PyLong_AsDouble(obj);
+    if (!PyErr_Occurred()) {
+      if (val) *val = v;
+      return SWIG_OK;
+    } else {
+      PyErr_Clear();
+    }
+  }
+%#ifdef SWIG_PYTHON_CAST_MODE
+  {
+    int dispatch = 0;
+    double d = PyFloat_AsDouble(obj);
+    if (!PyErr_Occurred()) {
+      if (val) *val = d;
+      return SWIG_AddCast(SWIG_OK);
+    } else {
+      PyErr_Clear();
+    }
+    if (!dispatch) {
+      long v = PyLong_AsLong(obj);
+      if (!PyErr_Occurred()) {
+	if (val) *val = v;
+	return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
+      } else {
+	PyErr_Clear();
+      }
+    }
+  }
+%#endif
+  return res;
+}
+}
+
+
+
diff --git a/share/swig/3.0.12/python/pyrun.swg b/share/swig/3.0.12/python/pyrun.swg
new file mode 100644
index 0000000..ab1237f
--- /dev/null
+++ b/share/swig/3.0.12/python/pyrun.swg
@@ -0,0 +1,1827 @@
+/* -----------------------------------------------------------------------------
+ * pyrun.swg
+ *
+ * This file contains the runtime support for Python modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ *
+ * ----------------------------------------------------------------------------- */
+
+/* Common SWIG API */
+
+/* for raw pointers */
+#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+
+#ifdef SWIGPYTHON_BUILTIN
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(self, ptr, type, flags)
+#else
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
+#endif
+
+#define SWIG_InternalNewPointerObj(ptr, type, flags)	SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
+
+#define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
+#define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
+#define swig_owntype                                    int
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
+#define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)
+
+#define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
+#define SWIG_SetErrorMsg                        	SWIG_Python_SetErrorMsg				   
+#define SWIG_ErrorType(code)                    	SWIG_Python_ErrorType(code)                        
+#define SWIG_Error(code, msg)            		SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 
+#define SWIG_fail                        		goto fail					   
+
+
+/* Runtime API implementation */
+
+/* Error manipulation */
+
+SWIGINTERN void 
+SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
+  SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
+  PyErr_SetObject(errtype, obj);
+  Py_DECREF(obj);
+  SWIG_PYTHON_THREAD_END_BLOCK;
+}
+
+SWIGINTERN void 
+SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
+  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+  PyErr_SetString(errtype, msg);
+  SWIG_PYTHON_THREAD_END_BLOCK;
+}
+
+#define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
+
+/* Set a constant value */
+
+#if defined(SWIGPYTHON_BUILTIN)
+
+SWIGINTERN void
+SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
+  PyObject *s = PyString_InternFromString(key);
+  PyList_Append(seq, s);
+  Py_DECREF(s);
+}
+
+SWIGINTERN void
+SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {   
+#if PY_VERSION_HEX < 0x02030000
+  PyDict_SetItemString(d, (char *)name, obj);
+#else
+  PyDict_SetItemString(d, name, obj);
+#endif
+  Py_DECREF(obj);
+  if (public_interface)
+    SwigPyBuiltin_AddPublicSymbol(public_interface, name);
+}
+
+#else
+
+SWIGINTERN void
+SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
+#if PY_VERSION_HEX < 0x02030000
+  PyDict_SetItemString(d, (char *)name, obj);
+#else
+  PyDict_SetItemString(d, name, obj);
+#endif
+  Py_DECREF(obj);                            
+}
+
+#endif
+
+/* Append a value to the result obj */
+
+SWIGINTERN PyObject*
+SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
+#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
+  if (!result) {
+    result = obj;
+  } else if (result == Py_None) {
+    Py_DECREF(result);
+    result = obj;
+  } else {
+    if (!PyList_Check(result)) {
+      PyObject *o2 = result;
+      result = PyList_New(1);
+      PyList_SetItem(result, 0, o2);
+    }
+    PyList_Append(result,obj);
+    Py_DECREF(obj);
+  }
+  return result;
+#else
+  PyObject*   o2;
+  PyObject*   o3;
+  if (!result) {
+    result = obj;
+  } else if (result == Py_None) {
+    Py_DECREF(result);
+    result = obj;
+  } else {
+    if (!PyTuple_Check(result)) {
+      o2 = result;
+      result = PyTuple_New(1);
+      PyTuple_SET_ITEM(result, 0, o2);
+    }
+    o3 = PyTuple_New(1);
+    PyTuple_SET_ITEM(o3, 0, obj);
+    o2 = result;
+    result = PySequence_Concat(o2, o3);
+    Py_DECREF(o2);
+    Py_DECREF(o3);
+  }
+  return result;
+#endif
+}
+
+/* Unpack the argument tuple */
+
+SWIGINTERN Py_ssize_t
+SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
+{
+  if (!args) {
+    if (!min && !max) {
+      return 1;
+    } else {
+      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
+		   name, (min == max ? "" : "at least "), (int)min);
+      return 0;
+    }
+  }  
+  if (!PyTuple_Check(args)) {
+    if (min <= 1 && max >= 1) {
+      Py_ssize_t i;
+      objs[0] = args;
+      for (i = 1; i < max; ++i) {
+	objs[i] = 0;
+      }
+      return 2;
+    }
+    PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
+    return 0;
+  } else {
+    Py_ssize_t l = PyTuple_GET_SIZE(args);
+    if (l < min) {
+      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
+		   name, (min == max ? "" : "at least "), (int)min, (int)l);
+      return 0;
+    } else if (l > max) {
+      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
+		   name, (min == max ? "" : "at most "), (int)max, (int)l);
+      return 0;
+    } else {
+      Py_ssize_t i;
+      for (i = 0; i < l; ++i) {
+	objs[i] = PyTuple_GET_ITEM(args, i);
+      }
+      for (; l < max; ++l) {
+	objs[l] = 0;
+      }
+      return i + 1;
+    }    
+  }
+}
+
+/* A functor is a function object with one single object argument */
+#if PY_VERSION_HEX >= 0x02020000
+#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunctionObjArgs(functor, obj, NULL);
+#else
+#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunction(functor, "O", obj);
+#endif
+
+/*
+  Helper for static pointer initialization for both C and C++ code, for example
+  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
+*/
+#ifdef __cplusplus
+#define SWIG_STATIC_POINTER(var)  var
+#else
+#define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Pointer declarations
+ * ----------------------------------------------------------------------------- */
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
+#define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
+
+#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
+
+#define SWIG_BUILTIN_TP_INIT	    (SWIG_POINTER_OWN << 2)
+#define SWIG_BUILTIN_INIT	    (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*  How to access Py_None */
+#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#  ifndef SWIG_PYTHON_NO_BUILD_NONE
+#    ifndef SWIG_PYTHON_BUILD_NONE
+#      define SWIG_PYTHON_BUILD_NONE
+#    endif
+#  endif
+#endif
+
+#ifdef SWIG_PYTHON_BUILD_NONE
+#  ifdef Py_None
+#   undef Py_None
+#   define Py_None SWIG_Py_None()
+#  endif
+SWIGRUNTIMEINLINE PyObject * 
+_SWIG_Py_None(void)
+{
+  PyObject *none = Py_BuildValue((char*)"");
+  Py_DECREF(none);
+  return none;
+}
+SWIGRUNTIME PyObject * 
+SWIG_Py_None(void)
+{
+  static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
+  return none;
+}
+#endif
+
+/* The python void return value */
+
+SWIGRUNTIMEINLINE PyObject * 
+SWIG_Py_Void(void)
+{
+  PyObject *none = Py_None;
+  Py_INCREF(none);
+  return none;
+}
+
+/* SwigPyClientData */
+
+typedef struct {
+  PyObject *klass;
+  PyObject *newraw;
+  PyObject *newargs;
+  PyObject *destroy;
+  int delargs;
+  int implicitconv;
+  PyTypeObject *pytype;
+} SwigPyClientData;
+
+SWIGRUNTIMEINLINE int 
+SWIG_Python_CheckImplicit(swig_type_info *ty)
+{
+  SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
+  return data ? data->implicitconv : 0;
+}
+
+SWIGRUNTIMEINLINE PyObject *
+SWIG_Python_ExceptionType(swig_type_info *desc) {
+  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
+  PyObject *klass = data ? data->klass : 0;
+  return (klass ? klass : PyExc_RuntimeError);
+}
+
+
+SWIGRUNTIME SwigPyClientData * 
+SwigPyClientData_New(PyObject* obj)
+{
+  if (!obj) {
+    return 0;
+  } else {
+    SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
+    /* the klass element */
+    data->klass = obj;
+    Py_INCREF(data->klass);
+    /* the newraw method and newargs arguments used to create a new raw instance */
+    if (PyClass_Check(obj)) {
+      data->newraw = 0;
+      data->newargs = obj;
+      Py_INCREF(obj);
+    } else {
+#if (PY_VERSION_HEX < 0x02020000)
+      data->newraw = 0;
+#else
+      data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
+#endif
+      if (data->newraw) {
+	Py_INCREF(data->newraw);
+	data->newargs = PyTuple_New(1);
+	PyTuple_SetItem(data->newargs, 0, obj);
+      } else {
+	data->newargs = obj;
+      }
+      Py_INCREF(data->newargs);
+    }
+    /* the destroy method, aka as the C++ delete method */
+    data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
+    if (PyErr_Occurred()) {
+      PyErr_Clear();
+      data->destroy = 0;
+    }
+    if (data->destroy) {
+      int flags;
+      Py_INCREF(data->destroy);
+      flags = PyCFunction_GET_FLAGS(data->destroy);
+#ifdef METH_O
+      data->delargs = !(flags & (METH_O));
+#else
+      data->delargs = 0;
+#endif
+    } else {
+      data->delargs = 0;
+    }
+    data->implicitconv = 0;
+    data->pytype = 0;
+    return data;
+  }
+}
+
+SWIGRUNTIME void 
+SwigPyClientData_Del(SwigPyClientData *data) {
+  Py_XDECREF(data->newraw);
+  Py_XDECREF(data->newargs);
+  Py_XDECREF(data->destroy);
+}
+
+/* =============== SwigPyObject =====================*/
+
+typedef struct {
+  PyObject_HEAD
+  void *ptr;
+  swig_type_info *ty;
+  int own;
+  PyObject *next;
+#ifdef SWIGPYTHON_BUILTIN
+  PyObject *dict;
+#endif
+} SwigPyObject;
+
+
+#ifdef SWIGPYTHON_BUILTIN
+
+SWIGRUNTIME PyObject *
+SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
+{
+  SwigPyObject *sobj = (SwigPyObject *)v;
+
+  if (!sobj->dict)
+    sobj->dict = PyDict_New();
+
+  Py_INCREF(sobj->dict);
+  return sobj->dict;
+}
+
+#endif
+
+SWIGRUNTIME PyObject *
+SwigPyObject_long(SwigPyObject *v)
+{
+  return PyLong_FromVoidPtr(v->ptr);
+}
+
+SWIGRUNTIME PyObject *
+SwigPyObject_format(const char* fmt, SwigPyObject *v)
+{
+  PyObject *res = NULL;
+  PyObject *args = PyTuple_New(1);
+  if (args) {
+    if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
+      PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
+      if (ofmt) {
+#if PY_VERSION_HEX >= 0x03000000
+	res = PyUnicode_Format(ofmt,args);
+#else
+	res = PyString_Format(ofmt,args);
+#endif
+	Py_DECREF(ofmt);
+      }
+      Py_DECREF(args);
+    }
+  }
+  return res;
+}
+
+SWIGRUNTIME PyObject *
+SwigPyObject_oct(SwigPyObject *v)
+{
+  return SwigPyObject_format("%o",v);
+}
+
+SWIGRUNTIME PyObject *
+SwigPyObject_hex(SwigPyObject *v)
+{
+  return SwigPyObject_format("%x",v);
+}
+
+SWIGRUNTIME PyObject *
+#ifdef METH_NOARGS
+SwigPyObject_repr(SwigPyObject *v)
+#else
+SwigPyObject_repr(SwigPyObject *v, PyObject *args)
+#endif
+{
+  const char *name = SWIG_TypePrettyName(v->ty);
+  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
+  if (v->next) {
+# ifdef METH_NOARGS
+    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
+# else
+    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
+# endif
+# if PY_VERSION_HEX >= 0x03000000
+    PyObject *joined = PyUnicode_Concat(repr, nrep);
+    Py_DecRef(repr);
+    Py_DecRef(nrep);
+    repr = joined;
+# else
+    PyString_ConcatAndDel(&repr,nrep);
+# endif
+  }
+  return repr;  
+}
+
+SWIGRUNTIME int
+SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
+{
+  void *i = v->ptr;
+  void *j = w->ptr;
+  return (i < j) ? -1 : ((i > j) ? 1 : 0);
+}
+
+/* Added for Python 3.x, would it also be useful for Python 2.x? */
+SWIGRUNTIME PyObject*
+SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
+{
+  PyObject* res;
+  if( op != Py_EQ && op != Py_NE ) {
+    Py_INCREF(Py_NotImplemented);
+    return Py_NotImplemented;
+  }
+  res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
+  return res;  
+}
+
+
+SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
+
+#ifdef SWIGPYTHON_BUILTIN
+static swig_type_info *SwigPyObject_stype = 0;
+SWIGRUNTIME PyTypeObject*
+SwigPyObject_type(void) {
+    SwigPyClientData *cd;
+    assert(SwigPyObject_stype);
+    cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
+    assert(cd);
+    assert(cd->pytype);
+    return cd->pytype;
+}
+#else
+SWIGRUNTIME PyTypeObject*
+SwigPyObject_type(void) {
+  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
+  return type;
+}
+#endif
+
+SWIGRUNTIMEINLINE int
+SwigPyObject_Check(PyObject *op) {
+#ifdef SWIGPYTHON_BUILTIN
+  PyTypeObject *target_tp = SwigPyObject_type();
+  if (PyType_IsSubtype(op->ob_type, target_tp))
+    return 1;
+  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
+#else
+  return (Py_TYPE(op) == SwigPyObject_type())
+    || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
+#endif
+}
+
+SWIGRUNTIME PyObject *
+SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
+
+SWIGRUNTIME void
+SwigPyObject_dealloc(PyObject *v)
+{
+  SwigPyObject *sobj = (SwigPyObject *) v;
+  PyObject *next = sobj->next;
+  if (sobj->own == SWIG_POINTER_OWN) {
+    swig_type_info *ty = sobj->ty;
+    SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
+    PyObject *destroy = data ? data->destroy : 0;
+    if (destroy) {
+      /* destroy is always a VARARGS method */
+      PyObject *res;
+
+      /* PyObject_CallFunction() has the potential to silently drop
+         the active active exception.  In cases of unnamed temporary
+         variable or where we just finished iterating over a generator
+         StopIteration will be active right now, and this needs to
+         remain true upon return from SwigPyObject_dealloc.  So save
+         and restore. */
+      
+      PyObject *val = NULL, *type = NULL, *tb = NULL;
+      PyErr_Fetch(&val, &type, &tb);
+
+      if (data->delargs) {
+        /* we need to create a temporary object to carry the destroy operation */
+        PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
+        res = SWIG_Python_CallFunctor(destroy, tmp);
+        Py_DECREF(tmp);
+      } else {
+        PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
+        PyObject *mself = PyCFunction_GET_SELF(destroy);
+        res = ((*meth)(mself, v));
+      }
+      if (!res)
+        PyErr_WriteUnraisable(destroy);
+
+      PyErr_Restore(val, type, tb);
+
+      Py_XDECREF(res);
+    } 
+#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
+    else {
+      const char *name = SWIG_TypePrettyName(ty);
+      printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
+    }
+#endif
+  } 
+  Py_XDECREF(next);
+  PyObject_DEL(v);
+}
+
+SWIGRUNTIME PyObject* 
+SwigPyObject_append(PyObject* v, PyObject* next)
+{
+  SwigPyObject *sobj = (SwigPyObject *) v;
+#ifndef METH_O
+  PyObject *tmp = 0;
+  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
+  next = tmp;
+#endif
+  if (!SwigPyObject_Check(next)) {
+    PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
+    return NULL;
+  }
+  sobj->next = next;
+  Py_INCREF(next);
+  return SWIG_Py_Void();
+}
+
+SWIGRUNTIME PyObject* 
+#ifdef METH_NOARGS
+SwigPyObject_next(PyObject* v)
+#else
+SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
+#endif
+{
+  SwigPyObject *sobj = (SwigPyObject *) v;
+  if (sobj->next) {    
+    Py_INCREF(sobj->next);
+    return sobj->next;
+  } else {
+    return SWIG_Py_Void();
+  }
+}
+
+SWIGINTERN PyObject*
+#ifdef METH_NOARGS
+SwigPyObject_disown(PyObject *v)
+#else
+SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
+#endif
+{
+  SwigPyObject *sobj = (SwigPyObject *)v;
+  sobj->own = 0;
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject*
+#ifdef METH_NOARGS
+SwigPyObject_acquire(PyObject *v)
+#else
+SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
+#endif
+{
+  SwigPyObject *sobj = (SwigPyObject *)v;
+  sobj->own = SWIG_POINTER_OWN;
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject*
+SwigPyObject_own(PyObject *v, PyObject *args)
+{
+  PyObject *val = 0;
+#if (PY_VERSION_HEX < 0x02020000)
+  if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
+#elif (PY_VERSION_HEX < 0x02050000)
+  if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) 
+#else
+  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) 
+#endif
+    {
+      return NULL;
+    } 
+  else
+    {
+      SwigPyObject *sobj = (SwigPyObject *)v;
+      PyObject *obj = PyBool_FromLong(sobj->own);
+      if (val) {
+#ifdef METH_NOARGS
+	if (PyObject_IsTrue(val)) {
+	  SwigPyObject_acquire(v);
+	} else {
+	  SwigPyObject_disown(v);
+	}
+#else
+	if (PyObject_IsTrue(val)) {
+	  SwigPyObject_acquire(v,args);
+	} else {
+	  SwigPyObject_disown(v,args);
+	}
+#endif
+      } 
+      return obj;
+    }
+}
+
+#ifdef METH_O
+static PyMethodDef
+swigobject_methods[] = {
+  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
+  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"acquires ownership of the pointer"},
+  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
+  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)"appends another 'this' object"},
+  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
+  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
+  {0, 0, 0, 0}  
+};
+#else
+static PyMethodDef
+swigobject_methods[] = {
+  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
+  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS,  (char *)"acquires ownership of the pointer"},
+  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
+  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
+  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
+  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
+  {0, 0, 0, 0}  
+};
+#endif
+
+#if PY_VERSION_HEX < 0x02020000
+SWIGINTERN PyObject *
+SwigPyObject_getattr(SwigPyObject *sobj,char *name)
+{
+  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
+}
+#endif
+
+SWIGRUNTIME PyTypeObject*
+SwigPyObject_TypeOnce(void) {
+  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
+
+  static PyNumberMethods SwigPyObject_as_number = {
+    (binaryfunc)0, /*nb_add*/
+    (binaryfunc)0, /*nb_subtract*/
+    (binaryfunc)0, /*nb_multiply*/
+    /* nb_divide removed in Python 3 */
+#if PY_VERSION_HEX < 0x03000000
+    (binaryfunc)0, /*nb_divide*/
+#endif
+    (binaryfunc)0, /*nb_remainder*/
+    (binaryfunc)0, /*nb_divmod*/
+    (ternaryfunc)0,/*nb_power*/
+    (unaryfunc)0,  /*nb_negative*/
+    (unaryfunc)0,  /*nb_positive*/
+    (unaryfunc)0,  /*nb_absolute*/
+    (inquiry)0,    /*nb_nonzero*/
+    0,		   /*nb_invert*/
+    0,		   /*nb_lshift*/
+    0,		   /*nb_rshift*/
+    0,		   /*nb_and*/
+    0,		   /*nb_xor*/
+    0,		   /*nb_or*/
+#if PY_VERSION_HEX < 0x03000000
+    0,   /*nb_coerce*/
+#endif
+    (unaryfunc)SwigPyObject_long, /*nb_int*/
+#if PY_VERSION_HEX < 0x03000000
+    (unaryfunc)SwigPyObject_long, /*nb_long*/
+#else
+    0, /*nb_reserved*/
+#endif
+    (unaryfunc)0,                 /*nb_float*/
+#if PY_VERSION_HEX < 0x03000000
+    (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
+    (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
+#endif
+#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
+#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
+#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
+#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
+#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
+    0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
+#endif
+  };
+
+  static PyTypeObject swigpyobject_type;
+  static int type_init = 0;
+  if (!type_init) {
+    const PyTypeObject tmp = {
+#if PY_VERSION_HEX >= 0x03000000
+      PyVarObject_HEAD_INIT(NULL, 0)
+#else
+      PyObject_HEAD_INIT(NULL)
+      0,                                    /* ob_size */
+#endif
+      (char *)"SwigPyObject",               /* tp_name */
+      sizeof(SwigPyObject),                 /* tp_basicsize */
+      0,                                    /* tp_itemsize */
+      (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
+      0,                                    /* tp_print */
+#if PY_VERSION_HEX < 0x02020000
+      (getattrfunc)SwigPyObject_getattr,    /* tp_getattr */
+#else
+      (getattrfunc)0,                       /* tp_getattr */
+#endif
+      (setattrfunc)0,                       /* tp_setattr */
+#if PY_VERSION_HEX >= 0x03000000
+      0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
+#else
+      (cmpfunc)SwigPyObject_compare,        /* tp_compare */
+#endif
+      (reprfunc)SwigPyObject_repr,          /* tp_repr */
+      &SwigPyObject_as_number,              /* tp_as_number */
+      0,                                    /* tp_as_sequence */
+      0,                                    /* tp_as_mapping */
+      (hashfunc)0,                          /* tp_hash */
+      (ternaryfunc)0,                       /* tp_call */
+      0,                                    /* tp_str */
+      PyObject_GenericGetAttr,              /* tp_getattro */
+      0,                                    /* tp_setattro */
+      0,                                    /* tp_as_buffer */
+      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
+      swigobject_doc,                       /* tp_doc */
+      0,                                    /* tp_traverse */
+      0,                                    /* tp_clear */
+      (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
+      0,                                    /* tp_weaklistoffset */
+#if PY_VERSION_HEX >= 0x02020000
+      0,                                    /* tp_iter */
+      0,                                    /* tp_iternext */
+      swigobject_methods,                   /* tp_methods */
+      0,                                    /* tp_members */
+      0,                                    /* tp_getset */
+      0,                                    /* tp_base */
+      0,                                    /* tp_dict */
+      0,                                    /* tp_descr_get */
+      0,                                    /* tp_descr_set */
+      0,                                    /* tp_dictoffset */
+      0,                                    /* tp_init */
+      0,                                    /* tp_alloc */
+      0,                                    /* tp_new */
+      0,                                    /* tp_free */
+      0,                                    /* tp_is_gc */
+      0,                                    /* tp_bases */
+      0,                                    /* tp_mro */
+      0,                                    /* tp_cache */
+      0,                                    /* tp_subclasses */
+      0,                                    /* tp_weaklist */
+#endif
+#if PY_VERSION_HEX >= 0x02030000
+      0,                                    /* tp_del */
+#endif
+#if PY_VERSION_HEX >= 0x02060000
+      0,                                    /* tp_version_tag */
+#endif
+#if PY_VERSION_HEX >= 0x03040000
+      0,                                    /* tp_finalize */
+#endif
+#ifdef COUNT_ALLOCS
+      0,                                    /* tp_allocs */
+      0,                                    /* tp_frees */
+      0,                                    /* tp_maxalloc */
+#if PY_VERSION_HEX >= 0x02050000
+      0,                                    /* tp_prev */
+#endif
+      0                                     /* tp_next */
+#endif
+    };
+    swigpyobject_type = tmp;
+    type_init = 1;
+#if PY_VERSION_HEX < 0x02020000
+    swigpyobject_type.ob_type = &PyType_Type;
+#else
+    if (PyType_Ready(&swigpyobject_type) < 0)
+      return NULL;
+#endif
+  }
+  return &swigpyobject_type;
+}
+
+SWIGRUNTIME PyObject *
+SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
+{
+  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
+  if (sobj) {
+    sobj->ptr  = ptr;
+    sobj->ty   = ty;
+    sobj->own  = own;
+    sobj->next = 0;
+  }
+  return (PyObject *)sobj;
+}
+
+/* -----------------------------------------------------------------------------
+ * Implements a simple Swig Packed type, and use it instead of string
+ * ----------------------------------------------------------------------------- */
+
+typedef struct {
+  PyObject_HEAD
+  void *pack;
+  swig_type_info *ty;
+  size_t size;
+} SwigPyPacked;
+
+SWIGRUNTIME int
+SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
+{
+  char result[SWIG_BUFFER_SIZE];
+  fputs("<Swig Packed ", fp); 
+  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
+    fputs("at ", fp); 
+    fputs(result, fp); 
+  }
+  fputs(v->ty->name,fp); 
+  fputs(">", fp);
+  return 0; 
+}
+  
+SWIGRUNTIME PyObject *
+SwigPyPacked_repr(SwigPyPacked *v)
+{
+  char result[SWIG_BUFFER_SIZE];
+  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
+    return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
+  } else {
+    return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
+  }  
+}
+
+SWIGRUNTIME PyObject *
+SwigPyPacked_str(SwigPyPacked *v)
+{
+  char result[SWIG_BUFFER_SIZE];
+  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
+    return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
+  } else {
+    return SWIG_Python_str_FromChar(v->ty->name);
+  }  
+}
+
+SWIGRUNTIME int
+SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
+{
+  size_t i = v->size;
+  size_t j = w->size;
+  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
+  return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
+}
+
+SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
+
+SWIGRUNTIME PyTypeObject*
+SwigPyPacked_type(void) {
+  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
+  return type;
+}
+
+SWIGRUNTIMEINLINE int
+SwigPyPacked_Check(PyObject *op) {
+  return ((op)->ob_type == SwigPyPacked_TypeOnce()) 
+    || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
+}
+
+SWIGRUNTIME void
+SwigPyPacked_dealloc(PyObject *v)
+{
+  if (SwigPyPacked_Check(v)) {
+    SwigPyPacked *sobj = (SwigPyPacked *) v;
+    free(sobj->pack);
+  }
+  PyObject_DEL(v);
+}
+
+SWIGRUNTIME PyTypeObject*
+SwigPyPacked_TypeOnce(void) {
+  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
+  static PyTypeObject swigpypacked_type;
+  static int type_init = 0;
+  if (!type_init) {
+    const PyTypeObject tmp = {
+#if PY_VERSION_HEX>=0x03000000
+      PyVarObject_HEAD_INIT(NULL, 0)
+#else
+      PyObject_HEAD_INIT(NULL)
+      0,                                    /* ob_size */
+#endif
+      (char *)"SwigPyPacked",               /* tp_name */
+      sizeof(SwigPyPacked),                 /* tp_basicsize */
+      0,                                    /* tp_itemsize */
+      (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
+      (printfunc)SwigPyPacked_print,        /* tp_print */
+      (getattrfunc)0,                       /* tp_getattr */
+      (setattrfunc)0,                       /* tp_setattr */
+#if PY_VERSION_HEX>=0x03000000
+      0, /* tp_reserved in 3.0.1 */
+#else
+      (cmpfunc)SwigPyPacked_compare,        /* tp_compare */
+#endif
+      (reprfunc)SwigPyPacked_repr,          /* tp_repr */
+      0,                                    /* tp_as_number */
+      0,                                    /* tp_as_sequence */
+      0,                                    /* tp_as_mapping */
+      (hashfunc)0,                          /* tp_hash */
+      (ternaryfunc)0,                       /* tp_call */
+      (reprfunc)SwigPyPacked_str,           /* tp_str */
+      PyObject_GenericGetAttr,              /* tp_getattro */
+      0,                                    /* tp_setattro */
+      0,                                    /* tp_as_buffer */
+      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
+      swigpacked_doc,                       /* tp_doc */
+      0,                                    /* tp_traverse */
+      0,                                    /* tp_clear */
+      0,                                    /* tp_richcompare */
+      0,                                    /* tp_weaklistoffset */
+#if PY_VERSION_HEX >= 0x02020000
+      0,                                    /* tp_iter */
+      0,                                    /* tp_iternext */
+      0,                                    /* tp_methods */
+      0,                                    /* tp_members */
+      0,                                    /* tp_getset */
+      0,                                    /* tp_base */
+      0,                                    /* tp_dict */
+      0,                                    /* tp_descr_get */
+      0,                                    /* tp_descr_set */
+      0,                                    /* tp_dictoffset */
+      0,                                    /* tp_init */
+      0,                                    /* tp_alloc */
+      0,                                    /* tp_new */
+      0,                                    /* tp_free */
+      0,                                    /* tp_is_gc */
+      0,                                    /* tp_bases */
+      0,                                    /* tp_mro */
+      0,                                    /* tp_cache */
+      0,                                    /* tp_subclasses */
+      0,                                    /* tp_weaklist */
+#endif
+#if PY_VERSION_HEX >= 0x02030000
+      0,                                    /* tp_del */
+#endif
+#if PY_VERSION_HEX >= 0x02060000
+      0,                                    /* tp_version_tag */
+#endif
+#if PY_VERSION_HEX >= 0x03040000
+      0,                                    /* tp_finalize */
+#endif
+#ifdef COUNT_ALLOCS
+      0,                                    /* tp_allocs */
+      0,                                    /* tp_frees */
+      0,                                    /* tp_maxalloc */
+#if PY_VERSION_HEX >= 0x02050000
+      0,                                    /* tp_prev */
+#endif
+      0                                     /* tp_next */
+#endif
+    };
+    swigpypacked_type = tmp;
+    type_init = 1;
+#if PY_VERSION_HEX < 0x02020000
+    swigpypacked_type.ob_type = &PyType_Type;
+#else
+    if (PyType_Ready(&swigpypacked_type) < 0)
+      return NULL;
+#endif
+  }
+  return &swigpypacked_type;
+}
+
+SWIGRUNTIME PyObject *
+SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
+{
+  SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
+  if (sobj) {
+    void *pack = malloc(size);
+    if (pack) {
+      memcpy(pack, ptr, size);
+      sobj->pack = pack;
+      sobj->ty   = ty;
+      sobj->size = size;
+    } else {
+      PyObject_DEL((PyObject *) sobj);
+      sobj = 0;
+    }
+  }
+  return (PyObject *) sobj;
+}
+
+SWIGRUNTIME swig_type_info *
+SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
+{
+  if (SwigPyPacked_Check(obj)) {
+    SwigPyPacked *sobj = (SwigPyPacked *)obj;
+    if (sobj->size != size) return 0;
+    memcpy(ptr, sobj->pack, size);
+    return sobj->ty;
+  } else {
+    return 0;
+  }
+}
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+SWIGRUNTIMEINLINE PyObject *
+_SWIG_This(void)
+{
+    return SWIG_Python_str_FromChar("this");
+}
+
+static PyObject *swig_this = NULL;
+
+SWIGRUNTIME PyObject *
+SWIG_This(void)
+{
+  if (swig_this == NULL)
+    swig_this = _SWIG_This();
+  return swig_this;
+}
+
+/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
+
+/* TODO: I don't know how to implement the fast getset in Python 3 right now */
+#if PY_VERSION_HEX>=0x03000000
+#define SWIG_PYTHON_SLOW_GETSET_THIS 
+#endif
+
+SWIGRUNTIME SwigPyObject *
+SWIG_Python_GetSwigThis(PyObject *pyobj) 
+{
+  PyObject *obj;
+
+  if (SwigPyObject_Check(pyobj))
+    return (SwigPyObject *) pyobj;
+
+#ifdef SWIGPYTHON_BUILTIN
+  (void)obj;
+# ifdef PyWeakref_CheckProxy
+  if (PyWeakref_CheckProxy(pyobj)) {
+    pyobj = PyWeakref_GET_OBJECT(pyobj);
+    if (pyobj && SwigPyObject_Check(pyobj))
+      return (SwigPyObject*) pyobj;
+  }
+# endif
+  return NULL;
+#else
+
+  obj = 0;
+
+#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
+  if (PyInstance_Check(pyobj)) {
+    obj = _PyInstance_Lookup(pyobj, SWIG_This());      
+  } else {
+    PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
+    if (dictptr != NULL) {
+      PyObject *dict = *dictptr;
+      obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
+    } else {
+#ifdef PyWeakref_CheckProxy
+      if (PyWeakref_CheckProxy(pyobj)) {
+	PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
+	return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
+      }
+#endif
+      obj = PyObject_GetAttr(pyobj,SWIG_This());
+      if (obj) {
+	Py_DECREF(obj);
+      } else {
+	if (PyErr_Occurred()) PyErr_Clear();
+	return 0;
+      }
+    }
+  }
+#else
+  obj = PyObject_GetAttr(pyobj,SWIG_This());
+  if (obj) {
+    Py_DECREF(obj);
+  } else {
+    if (PyErr_Occurred()) PyErr_Clear();
+    return 0;
+  }
+#endif
+  if (obj && !SwigPyObject_Check(obj)) {
+    /* a PyObject is called 'this', try to get the 'real this'
+       SwigPyObject from it */ 
+    return SWIG_Python_GetSwigThis(obj);
+  }
+  return (SwigPyObject *)obj;
+#endif
+}
+
+/* Acquire a pointer value */
+
+SWIGRUNTIME int
+SWIG_Python_AcquirePtr(PyObject *obj, int own) {
+  if (own == SWIG_POINTER_OWN) {
+    SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
+    if (sobj) {
+      int oldown = sobj->own;
+      sobj->own = own;
+      return oldown;
+    }
+  }
+  return 0;
+}
+
+/* Convert a pointer value */
+
+SWIGRUNTIME int
+SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
+  int res;
+  SwigPyObject *sobj;
+  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
+
+  if (!obj)
+    return SWIG_ERROR;
+  if (obj == Py_None && !implicit_conv) {
+    if (ptr)
+      *ptr = 0;
+    return SWIG_OK;
+  }
+
+  res = SWIG_ERROR;
+
+  sobj = SWIG_Python_GetSwigThis(obj);
+  if (own)
+    *own = 0;
+  while (sobj) {
+    void *vptr = sobj->ptr;
+    if (ty) {
+      swig_type_info *to = sobj->ty;
+      if (to == ty) {
+        /* no type cast needed */
+        if (ptr) *ptr = vptr;
+        break;
+      } else {
+        swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
+        if (!tc) {
+          sobj = (SwigPyObject *)sobj->next;
+        } else {
+          if (ptr) {
+            int newmemory = 0;
+            *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
+            if (newmemory == SWIG_CAST_NEW_MEMORY) {
+              assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+              if (own)
+                *own = *own | SWIG_CAST_NEW_MEMORY;
+            }
+          }
+          break;
+        }
+      }
+    } else {
+      if (ptr) *ptr = vptr;
+      break;
+    }
+  }
+  if (sobj) {
+    if (own)
+      *own = *own | sobj->own;
+    if (flags & SWIG_POINTER_DISOWN) {
+      sobj->own = 0;
+    }
+    res = SWIG_OK;
+  } else {
+    if (implicit_conv) {
+      SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
+      if (data && !data->implicitconv) {
+        PyObject *klass = data->klass;
+        if (klass) {
+          PyObject *impconv;
+          data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
+          impconv = SWIG_Python_CallFunctor(klass, obj);
+          data->implicitconv = 0;
+          if (PyErr_Occurred()) {
+            PyErr_Clear();
+            impconv = 0;
+          }
+          if (impconv) {
+            SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
+            if (iobj) {
+              void *vptr;
+              res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
+              if (SWIG_IsOK(res)) {
+                if (ptr) {
+                  *ptr = vptr;
+                  /* transfer the ownership to 'ptr' */
+                  iobj->own = 0;
+                  res = SWIG_AddCast(res);
+                  res = SWIG_AddNewMask(res);
+                } else {
+                  res = SWIG_AddCast(res);		    
+                }
+              }
+            }
+            Py_DECREF(impconv);
+          }
+        }
+      }
+    }
+    if (!SWIG_IsOK(res) && obj == Py_None) {
+      if (ptr)
+        *ptr = 0;
+      if (PyErr_Occurred())
+        PyErr_Clear();
+      res = SWIG_OK;
+    }
+  }
+  return res;
+}
+
+/* Convert a function ptr value */
+
+SWIGRUNTIME int
+SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
+  if (!PyCFunction_Check(obj)) {
+    return SWIG_ConvertPtr(obj, ptr, ty, 0);
+  } else {
+    void *vptr = 0;
+    
+    /* here we get the method pointer for callbacks */
+    const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
+    const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
+    if (desc)
+      desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
+    if (!desc) 
+      return SWIG_ERROR;
+    if (ty) {
+      swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
+      if (tc) {
+        int newmemory = 0;
+        *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
+        assert(!newmemory); /* newmemory handling not yet implemented */
+      } else {
+        return SWIG_ERROR;
+      }
+    } else {
+      *ptr = vptr;
+    }
+    return SWIG_OK;
+  }
+}
+
+/* Convert a packed value value */
+
+SWIGRUNTIME int
+SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
+  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
+  if (!to) return SWIG_ERROR;
+  if (ty) {
+    if (to != ty) {
+      /* check type cast? */
+      swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
+      if (!tc) return SWIG_ERROR;
+    }
+  }
+  return SWIG_OK;
+}  
+
+/* -----------------------------------------------------------------------------
+ * Create a new pointer object
+ * ----------------------------------------------------------------------------- */
+
+/*
+  Create a new instance object, without calling __init__, and set the
+  'this' attribute.
+*/
+
+SWIGRUNTIME PyObject* 
+SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
+{
+#if (PY_VERSION_HEX >= 0x02020000)
+  PyObject *inst = 0;
+  PyObject *newraw = data->newraw;
+  if (newraw) {
+    inst = PyObject_Call(newraw, data->newargs, NULL);
+    if (inst) {
+#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
+      PyObject **dictptr = _PyObject_GetDictPtr(inst);
+      if (dictptr != NULL) {
+	PyObject *dict = *dictptr;
+	if (dict == NULL) {
+	  dict = PyDict_New();
+	  *dictptr = dict;
+	  PyDict_SetItem(dict, SWIG_This(), swig_this);
+	}
+      }
+#else
+      PyObject *key = SWIG_This();
+      PyObject_SetAttr(inst, key, swig_this);
+#endif
+    }
+  } else {
+#if PY_VERSION_HEX >= 0x03000000
+    inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
+    if (inst) {
+      PyObject_SetAttr(inst, SWIG_This(), swig_this);
+      Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
+    }
+#else
+    PyObject *dict = PyDict_New();
+    if (dict) {
+      PyDict_SetItem(dict, SWIG_This(), swig_this);
+      inst = PyInstance_NewRaw(data->newargs, dict);
+      Py_DECREF(dict);
+    }
+#endif
+  }
+  return inst;
+#else
+#if (PY_VERSION_HEX >= 0x02010000)
+  PyObject *inst = 0;
+  PyObject *dict = PyDict_New();
+  if (dict) {
+    PyDict_SetItem(dict, SWIG_This(), swig_this);
+    inst = PyInstance_NewRaw(data->newargs, dict);
+    Py_DECREF(dict);
+  }
+  return (PyObject *) inst;
+#else
+  PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
+  if (inst == NULL) {
+    return NULL;
+  }
+  inst->in_class = (PyClassObject *)data->newargs;
+  Py_INCREF(inst->in_class);
+  inst->in_dict = PyDict_New();
+  if (inst->in_dict == NULL) {
+    Py_DECREF(inst);
+    return NULL;
+  }
+#ifdef Py_TPFLAGS_HAVE_WEAKREFS
+  inst->in_weakreflist = NULL;
+#endif
+#ifdef Py_TPFLAGS_GC
+  PyObject_GC_Init(inst);
+#endif
+  PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
+  return (PyObject *) inst;
+#endif
+#endif
+}
+
+SWIGRUNTIME void
+SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
+{
+ PyObject *dict;
+#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
+ PyObject **dictptr = _PyObject_GetDictPtr(inst);
+ if (dictptr != NULL) {
+   dict = *dictptr;
+   if (dict == NULL) {
+     dict = PyDict_New();
+     *dictptr = dict;
+   }
+   PyDict_SetItem(dict, SWIG_This(), swig_this);
+   return;
+ }
+#endif
+ dict = PyObject_GetAttrString(inst, (char*)"__dict__");
+ PyDict_SetItem(dict, SWIG_This(), swig_this);
+ Py_DECREF(dict);
+} 
+
+
+SWIGINTERN PyObject *
+SWIG_Python_InitShadowInstance(PyObject *args) {
+  PyObject *obj[2];
+  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
+    return NULL;
+  } else {
+    SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
+    if (sthis) {
+      SwigPyObject_append((PyObject*) sthis, obj[1]);
+    } else {
+      SWIG_Python_SetSwigThis(obj[0], obj[1]);
+    }
+    return SWIG_Py_Void();
+  }
+}
+
+/* Create a new pointer object */
+
+SWIGRUNTIME PyObject *
+SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
+  SwigPyClientData *clientdata;
+  PyObject * robj;
+  int own;
+
+  if (!ptr)
+    return SWIG_Py_Void();
+
+  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
+  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
+  if (clientdata && clientdata->pytype) {
+    SwigPyObject *newobj;
+    if (flags & SWIG_BUILTIN_TP_INIT) {
+      newobj = (SwigPyObject*) self;
+      if (newobj->ptr) {
+        PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
+        while (newobj->next)
+	  newobj = (SwigPyObject *) newobj->next;
+        newobj->next = next_self;
+        newobj = (SwigPyObject *)next_self;
+#ifdef SWIGPYTHON_BUILTIN
+        newobj->dict = 0;
+#endif
+      }
+    } else {
+      newobj = PyObject_New(SwigPyObject, clientdata->pytype);
+#ifdef SWIGPYTHON_BUILTIN
+      newobj->dict = 0;
+#endif
+    }
+    if (newobj) {
+      newobj->ptr = ptr;
+      newobj->ty = type;
+      newobj->own = own;
+      newobj->next = 0;
+      return (PyObject*) newobj;
+    }
+    return SWIG_Py_Void();
+  }
+
+  assert(!(flags & SWIG_BUILTIN_TP_INIT));
+
+  robj = SwigPyObject_New(ptr, type, own);
+  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
+    PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
+    Py_DECREF(robj);
+    robj = inst;
+  }
+  return robj;
+}
+
+/* Create a new packed object */
+
+SWIGRUNTIMEINLINE PyObject *
+SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
+  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
+}
+
+/* -----------------------------------------------------------------------------*
+ *  Get type list 
+ * -----------------------------------------------------------------------------*/
+
+#ifdef SWIG_LINK_RUNTIME
+void *SWIG_ReturnGlobalTypeList(void *);
+#endif
+
+SWIGRUNTIME swig_module_info *
+SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
+  static void *type_pointer = (void *)0;
+  /* first check if module already created */
+  if (!type_pointer) {
+#ifdef SWIG_LINK_RUNTIME
+    type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
+#else
+# ifdef SWIGPY_USE_CAPSULE
+    type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
+# else
+    type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
+				    (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
+# endif
+    if (PyErr_Occurred()) {
+      PyErr_Clear();
+      type_pointer = (void *)0;
+    }
+#endif
+  }
+  return (swig_module_info *) type_pointer;
+}
+
+#if PY_MAJOR_VERSION < 2
+/* PyModule_AddObject function was introduced in Python 2.0.  The following function
+   is copied out of Python/modsupport.c in python version 2.3.4 */
+SWIGINTERN int
+PyModule_AddObject(PyObject *m, char *name, PyObject *o)
+{
+  PyObject *dict;
+  if (!PyModule_Check(m)) {
+    PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg");
+    return SWIG_ERROR;
+  }
+  if (!o) {
+    PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
+    return SWIG_ERROR;
+  }
+  
+  dict = PyModule_GetDict(m);
+  if (dict == NULL) {
+    /* Internal error -- modules must have a dict! */
+    PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
+		 PyModule_GetName(m));
+    return SWIG_ERROR;
+  }
+  if (PyDict_SetItemString(dict, name, o))
+    return SWIG_ERROR;
+  Py_DECREF(o);
+  return SWIG_OK;
+}
+#endif
+
+SWIGRUNTIME void
+#ifdef SWIGPY_USE_CAPSULE
+SWIG_Python_DestroyModule(PyObject *obj)
+#else
+SWIG_Python_DestroyModule(void *vptr)
+#endif
+{
+#ifdef SWIGPY_USE_CAPSULE
+  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
+#else
+  swig_module_info *swig_module = (swig_module_info *) vptr;
+#endif
+  swig_type_info **types = swig_module->types;
+  size_t i;
+  for (i =0; i < swig_module->size; ++i) {
+    swig_type_info *ty = types[i];
+    if (ty->owndata) {
+      SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
+      if (data) SwigPyClientData_Del(data);
+    }
+  }
+  Py_DECREF(SWIG_This());
+  swig_this = NULL;
+}
+
+SWIGRUNTIME void
+SWIG_Python_SetModule(swig_module_info *swig_module) {
+#if PY_VERSION_HEX >= 0x03000000
+ /* Add a dummy module object into sys.modules */
+  PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
+#else
+  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
+  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
+#endif
+#ifdef SWIGPY_USE_CAPSULE
+  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
+  if (pointer && module) {
+    PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
+  } else {
+    Py_XDECREF(pointer);
+  }
+#else
+  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
+  if (pointer && module) {
+    PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
+  } else {
+    Py_XDECREF(pointer);
+  }
+#endif
+}
+
+/* The python cached type query */
+SWIGRUNTIME PyObject *
+SWIG_Python_TypeCache(void) {
+  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
+  return cache;
+}
+
+SWIGRUNTIME swig_type_info *
+SWIG_Python_TypeQuery(const char *type)
+{
+  PyObject *cache = SWIG_Python_TypeCache();
+  PyObject *key = SWIG_Python_str_FromChar(type); 
+  PyObject *obj = PyDict_GetItem(cache, key);
+  swig_type_info *descriptor;
+  if (obj) {
+#ifdef SWIGPY_USE_CAPSULE
+    descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
+#else
+    descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
+#endif
+  } else {
+    swig_module_info *swig_module = SWIG_GetModule(0);
+    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
+    if (descriptor) {
+#ifdef SWIGPY_USE_CAPSULE
+      obj = PyCapsule_New((void*) descriptor, NULL, NULL);
+#else
+      obj = PyCObject_FromVoidPtr(descriptor, NULL);
+#endif
+      PyDict_SetItem(cache, key, obj);
+      Py_DECREF(obj);
+    }
+  }
+  Py_DECREF(key);
+  return descriptor;
+}
+
+/* 
+   For backward compatibility only
+*/
+#define SWIG_POINTER_EXCEPTION  0
+#define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
+#define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
+
+SWIGRUNTIME int
+SWIG_Python_AddErrMesg(const char* mesg, int infront)
+{  
+  if (PyErr_Occurred()) {
+    PyObject *type = 0;
+    PyObject *value = 0;
+    PyObject *traceback = 0;
+    PyErr_Fetch(&type, &value, &traceback);
+    if (value) {
+      char *tmp;
+      PyObject *old_str = PyObject_Str(value);
+      Py_XINCREF(type);
+      PyErr_Clear();
+      if (infront) {
+	PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
+      } else {
+	PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
+      }
+      SWIG_Python_str_DelForPy3(tmp);
+      Py_DECREF(old_str);
+    }
+    return 1;
+  } else {
+    return 0;
+  }
+}
+  
+SWIGRUNTIME int
+SWIG_Python_ArgFail(int argnum)
+{
+  if (PyErr_Occurred()) {
+    /* add information about failing argument */
+    char mesg[256];
+    PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
+    return SWIG_Python_AddErrMesg(mesg, 1);
+  } else {
+    return 0;
+  }
+}
+
+SWIGRUNTIMEINLINE const char *
+SwigPyObject_GetDesc(PyObject *self)
+{
+  SwigPyObject *v = (SwigPyObject *)self;
+  swig_type_info *ty = v ? v->ty : 0;
+  return ty ? ty->str : "";
+}
+
+SWIGRUNTIME void
+SWIG_Python_TypeError(const char *type, PyObject *obj)
+{
+  if (type) {
+#if defined(SWIG_COBJECT_TYPES)
+    if (obj && SwigPyObject_Check(obj)) {
+      const char *otype = (const char *) SwigPyObject_GetDesc(obj);
+      if (otype) {
+	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
+		     type, otype);
+	return;
+      }
+    } else 
+#endif      
+    {
+      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
+      if (otype) {
+	PyObject *str = PyObject_Str(obj);
+	const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
+	if (cstr) {
+	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
+		       type, otype, cstr);
+          SWIG_Python_str_DelForPy3(cstr);
+	} else {
+	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
+		       type, otype);
+	}
+	Py_XDECREF(str);
+	return;
+      }
+    }   
+    PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
+  } else {
+    PyErr_Format(PyExc_TypeError, "unexpected type is received");
+  }
+}
+
+
+/* Convert a pointer value, signal an exception on a type mismatch */
+SWIGRUNTIME void *
+SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
+  void *result;
+  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
+    PyErr_Clear();
+#if SWIG_POINTER_EXCEPTION
+    if (flags) {
+      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
+      SWIG_Python_ArgFail(argnum);
+    }
+#endif
+  }
+  return result;
+}
+
+#ifdef SWIGPYTHON_BUILTIN
+SWIGRUNTIME int
+SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
+  PyTypeObject *tp = obj->ob_type;
+  PyObject *descr;
+  PyObject *encoded_name;
+  descrsetfunc f;
+  int res = -1;
+
+# ifdef Py_USING_UNICODE
+  if (PyString_Check(name)) {
+    name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
+    if (!name)
+      return -1;
+  } else if (!PyUnicode_Check(name))
+# else
+  if (!PyString_Check(name))
+# endif
+  {
+    PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
+    return -1;
+  } else {
+    Py_INCREF(name);
+  }
+
+  if (!tp->tp_dict) {
+    if (PyType_Ready(tp) < 0)
+      goto done;
+  }
+
+  descr = _PyType_Lookup(tp, name);
+  f = NULL;
+  if (descr != NULL)
+    f = descr->ob_type->tp_descr_set;
+  if (!f) {
+    if (PyString_Check(name)) {
+      encoded_name = name;
+      Py_INCREF(name);
+    } else {
+      encoded_name = PyUnicode_AsUTF8String(name);
+    }
+    PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
+    Py_DECREF(encoded_name);
+  } else {
+    res = f(descr, obj, value);
+  }
+  
+  done:
+  Py_DECREF(name);
+  return res;
+}
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/share/swig/2.0.11/python/pyruntime.swg b/share/swig/3.0.12/python/pyruntime.swg
index fad97be..fad97be 100644
--- a/share/swig/2.0.11/python/pyruntime.swg
+++ b/share/swig/3.0.12/python/pyruntime.swg
diff --git a/share/swig/3.0.12/python/pystdcommon.swg b/share/swig/3.0.12/python/pystdcommon.swg
new file mode 100644
index 0000000..8372426
--- /dev/null
+++ b/share/swig/3.0.12/python/pystdcommon.swg
@@ -0,0 +1,261 @@
+%fragment("StdTraits","header",fragment="StdTraitsCommon")
+{
+namespace swig {  
+  /*
+    Traits that provides the from method
+  */
+  template <class Type> struct traits_from_ptr {
+    static PyObject *from(Type *val, int owner = 0) {
+      return SWIG_InternalNewPointerObj(val, type_info<Type>(), owner);
+    }
+  };
+
+  template <class Type> struct traits_from {
+    static PyObject *from(const Type& val) {
+      return traits_from_ptr<Type>::from(new Type(val), 1);
+    }
+  };
+
+  template <class Type> struct traits_from<Type *> {
+    static PyObject *from(Type* val) {
+      return traits_from_ptr<Type>::from(val, 0);
+    }
+  };
+
+  template <class Type> struct traits_from<const Type *> {
+    static PyObject *from(const Type* val) {
+      return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
+    }
+  };
+
+
+  template <class Type>
+  inline PyObject *from(const Type& val) {
+    return traits_from<Type>::from(val);
+  }
+
+  template <class Type>
+  inline PyObject *from_ptr(Type* val, int owner) {
+    return traits_from_ptr<Type>::from(val, owner);
+  }
+
+  /*
+    Traits that provides the asval/as/check method
+  */
+  template <class Type>
+  struct traits_asptr {   
+    static int asptr(PyObject *obj, Type **val) {
+      Type *p;
+      swig_type_info *descriptor = type_info<Type>();
+      int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
+      if (SWIG_IsOK(res)) {
+	if (val) *val = p;
+      }
+      return res;
+    }
+  }; 
+
+  template <class Type>
+  inline int asptr(PyObject *obj, Type **vptr) {
+    return traits_asptr<Type>::asptr(obj, vptr);
+  }
+
+  template <class Type> 
+  struct traits_asval {
+    static int asval(PyObject *obj, Type *val) {
+      if (val) {
+	Type *p = 0;
+	int res = traits_asptr<Type>::asptr(obj, &p);
+	if (!SWIG_IsOK(res)) return res;	
+	if (p) {
+	  typedef typename noconst_traits<Type>::noconst_type noconst_type;
+	  *(const_cast<noconst_type*>(val)) = *p;
+	  if (SWIG_IsNewObj(res)){
+	    %delete(p);
+	    res = SWIG_DelNewMask(res);
+	  }
+	  return res;
+	} else {
+	  return SWIG_ERROR;
+	}
+      } else {
+	return traits_asptr<Type>::asptr(obj, (Type **)(0));
+      }
+    }
+  };
+
+  template <class Type> struct traits_asval<Type*> {
+    static int asval(PyObject *obj, Type **val) {
+      if (val) {
+        typedef typename noconst_traits<Type>::noconst_type noconst_type;
+        noconst_type *p = 0;
+        int res = traits_asptr<noconst_type>::asptr(obj,  &p);
+        if (SWIG_IsOK(res)) {
+          *(const_cast<noconst_type**>(val)) = p;
+	}
+	return res;
+      } else {
+	return traits_asptr<Type>::asptr(obj, (Type **)(0));
+      }
+    }
+  };
+  
+  template <class Type>
+  inline int asval(PyObject *obj, Type *val) {
+    return traits_asval<Type>::asval(obj, val);
+  }
+
+  template <class Type> 
+  struct traits_as<Type, value_category> {
+    static Type as(PyObject *obj, bool throw_error) {
+      Type v;
+      int res = asval(obj, &v);
+      if (!obj || !SWIG_IsOK(res)) {
+	if (!PyErr_Occurred()) {
+	  ::%type_error(swig::type_name<Type>());
+	}
+	if (throw_error) throw std::invalid_argument("bad type");
+      }
+      return v;
+    }
+  };
+
+  template <class Type> 
+  struct traits_as<Type, pointer_category> {
+    static Type as(PyObject *obj, bool throw_error) {
+      Type *v = 0;      
+      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
+      if (SWIG_IsOK(res) && v) {
+	if (SWIG_IsNewObj(res)) {
+	  Type r(*v);
+	  %delete(v);
+	  return r;
+	} else {
+	  return *v;
+	}
+      } else {
+	// Uninitialized return value, no Type() constructor required.
+	static Type *v_def = (Type*) malloc(sizeof(Type));
+	if (!PyErr_Occurred()) {
+	  %type_error(swig::type_name<Type>());
+	}
+	if (throw_error) throw std::invalid_argument("bad type");
+	memset(v_def,0,sizeof(Type));
+	return *v_def;
+      }
+    }
+  };
+
+  template <class Type> 
+  struct traits_as<Type*, pointer_category> {
+    static Type* as(PyObject *obj, bool throw_error) {
+      Type *v = 0;      
+      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
+      if (SWIG_IsOK(res)) {
+	return v;
+      } else {
+	if (!PyErr_Occurred()) {
+	  %type_error(swig::type_name<Type>());
+	}
+	if (throw_error) throw std::invalid_argument("bad type");
+	return 0;
+      }
+    }
+  };
+    
+  template <class Type>
+  inline Type as(PyObject *obj, bool te = false) {
+    return traits_as<Type, typename traits<Type>::category>::as(obj, te);
+  }
+
+  template <class Type> 
+  struct traits_check<Type, value_category> {
+    static bool check(PyObject *obj) {
+      int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
+      return SWIG_IsOK(res) ? true : false;
+    }
+  };
+
+  template <class Type> 
+  struct traits_check<Type, pointer_category> {
+    static bool check(PyObject *obj) {
+      int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
+      return SWIG_IsOK(res) ? true : false;
+    }
+  };
+
+  template <class Type>
+  inline bool check(PyObject *obj) {
+    return traits_check<Type, typename traits<Type>::category>::check(obj);
+  }
+}
+}
+
+//
+// Backward compatibility
+//
+
+#ifdef SWIG_PYTHON_BACKWARD_COMP
+%fragment("<string>");
+%{
+PyObject* SwigInt_FromBool(bool b) {
+    return PyInt_FromLong(b ? 1L : 0L);
+}
+double SwigNumber_Check(PyObject* o) {
+    return PyFloat_Check(o) || PyInt_Check(o) || PyLong_Check(o);
+}
+double SwigNumber_AsDouble(PyObject* o) {
+    return PyFloat_Check(o) ? PyFloat_AsDouble(o)
+        : (PyInt_Check(o) ?   double(PyInt_AsLong(o))
+                            : double(PyLong_AsLong(o)));
+}
+PyObject* SwigString_FromString(const std::string& s) {
+    return PyString_FromStringAndSize(s.data(),s.size());
+}
+std::string SwigString_AsString(PyObject* o) {
+    return std::string(PyString_AsString(o));
+}
+%}
+
+#endif
+
+
+%define %specialize_std_container(Type,Check,As,From)
+%{
+namespace swig {
+  template <>  struct traits_asval<Type > {   
+    typedef Type value_type;
+    static int asval(PyObject *obj, value_type *val) {
+      if (Check(obj)) {
+	if (val) *val = As(obj);
+	return SWIG_OK;
+      }
+      return SWIG_ERROR;
+    }
+  };
+  template <>  struct traits_from<Type > {
+    typedef Type value_type;
+    static PyObject *from(const value_type& val) {
+      return From(val);
+    }
+  };
+
+  template <> 
+  struct traits_check<Type, value_category> {
+    static int check(PyObject *obj) {
+      int res = Check(obj);
+      return obj && res ? res : 0;
+    }
+  };
+}
+%}
+%enddef
+
+
+#define specialize_std_vector(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
+#define specialize_std_list(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
+#define specialize_std_deque(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
+#define specialize_std_set(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
+#define specialize_std_multiset(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
+#define specialize_std_unordered_set(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
+#define specialize_std_unordered_multiset(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
diff --git a/share/swig/3.0.12/python/pystrings.swg b/share/swig/3.0.12/python/pystrings.swg
new file mode 100644
index 0000000..fd37855
--- /dev/null
+++ b/share/swig/3.0.12/python/pystrings.swg
@@ -0,0 +1,147 @@
+/* ------------------------------------------------------------
+ *  utility methods for char strings 
+ * ------------------------------------------------------------ */
+%fragment("SWIG_AsCharPtrAndSize","header",fragment="SWIG_pchar_descriptor") {
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
+{
+%#if PY_VERSION_HEX>=0x03000000
+%#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
+  if (PyBytes_Check(obj))
+%#else
+  if (PyUnicode_Check(obj))
+%#endif
+%#else  
+  if (PyString_Check(obj))
+%#endif
+  {
+    char *cstr; Py_ssize_t len;
+%#if PY_VERSION_HEX>=0x03000000
+%#if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
+    if (!alloc && cptr) {
+        /* We can't allow converting without allocation, since the internal
+           representation of string in Python 3 is UCS-2/UCS-4 but we require
+           a UTF-8 representation.
+           TODO(bhy) More detailed explanation */
+        return SWIG_RuntimeError;
+    }
+    obj = PyUnicode_AsUTF8String(obj);
+    if(alloc) *alloc = SWIG_NEWOBJ;
+%#endif
+    PyBytes_AsStringAndSize(obj, &cstr, &len);
+%#else
+    PyString_AsStringAndSize(obj, &cstr, &len);
+%#endif
+    if (cptr) {
+      if (alloc) {
+	/* 
+	   In python the user should not be able to modify the inner
+	   string representation. To warranty that, if you define
+	   SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
+	   buffer is always returned.
+
+	   The default behavior is just to return the pointer value,
+	   so, be careful.
+	*/ 
+%#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
+	if (*alloc != SWIG_OLDOBJ) 
+%#else
+	if (*alloc == SWIG_NEWOBJ) 
+%#endif
+	{
+	  *cptr = %new_copy_array(cstr, len + 1, char);
+	  *alloc = SWIG_NEWOBJ;
+	} else {
+	  *cptr = cstr;
+	  *alloc = SWIG_OLDOBJ;
+	}
+      } else {
+%#if PY_VERSION_HEX>=0x03000000
+%#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
+	*cptr = PyBytes_AsString(obj);
+%#else
+	assert(0); /* Should never reach here with Unicode strings in Python 3 */
+%#endif
+%#else
+	*cptr = SWIG_Python_str_AsChar(obj);
+%#endif
+      }
+    }
+    if (psize) *psize = len + 1;
+%#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
+    Py_XDECREF(obj);
+%#endif
+    return SWIG_OK;
+  } else {
+%#if defined(SWIG_PYTHON_2_UNICODE)
+%#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
+%#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
+%#endif
+%#if PY_VERSION_HEX<0x03000000
+    if (PyUnicode_Check(obj)) {
+      char *cstr; Py_ssize_t len;
+      if (!alloc && cptr) {
+        return SWIG_RuntimeError;
+      }
+      obj = PyUnicode_AsUTF8String(obj);
+      if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
+        if (cptr) {
+          if (alloc) *alloc = SWIG_NEWOBJ;
+          *cptr = %new_copy_array(cstr, len + 1, char);
+        }
+        if (psize) *psize = len + 1;
+
+        Py_XDECREF(obj);
+        return SWIG_OK;
+      } else {
+        Py_XDECREF(obj);
+      }
+    }
+%#endif
+%#endif
+
+    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+    if (pchar_descriptor) {
+      void* vptr = 0;
+      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
+	if (cptr) *cptr = (char *) vptr;
+	if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
+	if (alloc) *alloc = SWIG_OLDOBJ;
+	return SWIG_OK;
+      }
+    }
+  }
+  return SWIG_TypeError;
+}
+}
+
+%fragment("SWIG_FromCharPtrAndSize","header",fragment="SWIG_pchar_descriptor") {
+SWIGINTERNINLINE PyObject *
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+  if (carray) {
+    if (size > INT_MAX) {
+      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+      return pchar_descriptor ? 
+	SWIG_InternalNewPointerObj(%const_cast(carray,char *), pchar_descriptor, 0) : SWIG_Py_Void();
+    } else {
+%#if PY_VERSION_HEX >= 0x03000000
+%#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
+      return PyBytes_FromStringAndSize(carray, %numeric_cast(size, Py_ssize_t));
+%#else
+%#if PY_VERSION_HEX >= 0x03010000
+      return PyUnicode_DecodeUTF8(carray, %numeric_cast(size, Py_ssize_t), "surrogateescape");
+%#else
+      return PyUnicode_FromStringAndSize(carray, %numeric_cast(size, Py_ssize_t));
+%#endif
+%#endif
+%#else
+      return PyString_FromStringAndSize(carray, %numeric_cast(size, Py_ssize_t));
+%#endif
+    }
+  } else {
+    return SWIG_Py_Void();
+  }
+}
+}
+
diff --git a/share/swig/2.0.11/python/python.swg b/share/swig/3.0.12/python/python.swg
index 769d9e1..769d9e1 100644
--- a/share/swig/2.0.11/python/python.swg
+++ b/share/swig/3.0.12/python/python.swg
diff --git a/share/swig/3.0.12/python/pythonkw.swg b/share/swig/3.0.12/python/pythonkw.swg
new file mode 100644
index 0000000..1a4329d
--- /dev/null
+++ b/share/swig/3.0.12/python/pythonkw.swg
@@ -0,0 +1,138 @@
+/*
+  Warnings for Python keywords, built-in names and bad names.
+*/
+
+#define PYTHONKW(x) %keywordwarn("'" `x` "' is a python keyword, renaming to '_" `x` "'", rename="_%s")  `x`
+#define PYTHONBN(x) %builtinwarn("'" `x` "' conflicts with a built-in name in python")  `x`
+
+
+/*
+  Warnings for Python keywords 
+  https://docs.python.org/2/reference/lexical_analysis.html#keywords
+*/
+
+PYTHONKW(and);
+PYTHONKW(as);
+PYTHONKW(assert);
+PYTHONKW(break);
+PYTHONKW(class);
+PYTHONKW(continue);
+PYTHONKW(def);
+PYTHONKW(del);
+PYTHONKW(elif);
+PYTHONKW(else);
+PYTHONKW(except);
+PYTHONKW(exec);
+PYTHONKW(finally);
+PYTHONKW(for);
+PYTHONKW(from);
+PYTHONKW(global);
+PYTHONKW(if);
+PYTHONKW(import);
+PYTHONKW(in);
+PYTHONKW(is);
+PYTHONKW(lambda);
+PYTHONKW(not);
+PYTHONKW(or);
+PYTHONKW(pass);
+PYTHONKW(print);
+PYTHONKW(raise);
+PYTHONKW(return);
+PYTHONKW(try);
+PYTHONKW(while);
+PYTHONKW(with);
+PYTHONKW(yield);
+
+/*
+  built-in functions
+  https://docs.python.org/2/library/functions.html
+ */ 
+
+PYTHONBN(abs);
+PYTHONBN(apply);
+PYTHONBN(bool);
+PYTHONBN(buffer);
+PYTHONBN(callable);
+PYTHONBN(chr);
+PYTHONBN(classmethod);
+PYTHONBN(cmp);
+PYTHONBN(coerce);
+PYTHONBN(compile);
+PYTHONBN(complex);
+PYTHONBN(delattr);
+PYTHONBN(dict);
+PYTHONBN(dir);
+PYTHONBN(divmod);
+PYTHONBN(enumerate);
+PYTHONBN(eval);
+PYTHONBN(execfile);
+PYTHONBN(file);
+PYTHONBN(filter);
+PYTHONBN(float);
+PYTHONBN(frozenset);
+PYTHONBN(getattr);
+PYTHONBN(globals);
+PYTHONBN(hasattr);
+PYTHONBN(hash);
+PYTHONBN(hex);
+PYTHONBN(id);
+PYTHONBN(input);
+PYTHONBN(int);
+PYTHONBN(intern);
+PYTHONBN(isinstance);
+PYTHONBN(issubclass);
+PYTHONBN(iter);
+PYTHONBN(len);
+PYTHONBN(list);
+PYTHONBN(locals);
+PYTHONBN(long);
+PYTHONBN(map);
+PYTHONBN(max);
+PYTHONBN(min);
+PYTHONBN(object);
+PYTHONBN(oct);
+PYTHONBN(open);
+PYTHONBN(ord);
+PYTHONBN(pow);
+PYTHONBN(property);
+PYTHONBN(range);
+PYTHONBN(raw_input);
+PYTHONBN(reduce);
+PYTHONBN(reload);
+PYTHONBN(repr);
+PYTHONBN(reversed);
+PYTHONBN(round);
+PYTHONBN(set);
+PYTHONBN(setattr);
+PYTHONBN(slice);
+PYTHONBN(sorted);
+PYTHONBN(staticmethod);
+PYTHONBN(str);
+PYTHONBN(sum);
+PYTHONBN(super);
+PYTHONBN(tuple);
+PYTHONBN(type);
+PYTHONBN(unichr);
+PYTHONBN(unicode);
+PYTHONBN(vars);
+PYTHONBN(xrange);
+PYTHONBN(zip);
+
+
+/* 
+   built-in names
+   boolean type and None
+*/
+PYTHONBN(True);
+PYTHONBN(False);
+
+PYTHONKW(None);
+
+
+/* 
+   'self' is also a bad Name
+*/
+PYTHONKW(self);
+
+#undef PYTHONBN
+#undef PYTHONKW
diff --git a/share/swig/2.0.11/python/pythreads.swg b/share/swig/3.0.12/python/pythreads.swg
index a7552f1..a7552f1 100644
--- a/share/swig/2.0.11/python/pythreads.swg
+++ b/share/swig/3.0.12/python/pythreads.swg
diff --git a/share/swig/2.0.11/python/pytuplehlp.swg b/share/swig/3.0.12/python/pytuplehlp.swg
index 32e1580..32e1580 100644
--- a/share/swig/2.0.11/python/pytuplehlp.swg
+++ b/share/swig/3.0.12/python/pytuplehlp.swg
diff --git a/share/swig/3.0.12/python/pytypemaps.swg b/share/swig/3.0.12/python/pytypemaps.swg
new file mode 100644
index 0000000..48b0bcd
--- /dev/null
+++ b/share/swig/3.0.12/python/pytypemaps.swg
@@ -0,0 +1,105 @@
+/* ------------------------------------------------------------
+ *  Typemap specializations for Python
+ * ------------------------------------------------------------ */
+
+/* ------------------------------------------------------------
+ *  Fragment section
+ * ------------------------------------------------------------ */
+#ifdef SWIG_PYTHON_LEGACY_BOOL
+// Default prior to SWIG 3.0.0
+#undef SWIG_TYPECHECK_BOOL
+%define SWIG_TYPECHECK_BOOL             10000 %enddef
+#endif
+
+/* Include fundamental fragment definitions */
+%include <typemaps/fragments.swg>
+
+/* Look for user fragments file. */
+%include <pyfragments.swg>
+
+/* Python fragments for fundamental types */
+%include <pyprimtypes.swg>
+
+/* Python fragments for char* strings */
+%include <pystrings.swg>
+
+/* Backward compatibility output helper */
+%fragment("t_output_helper","header") %{
+#define t_output_helper SWIG_Python_AppendOutput
+%}
+
+
+/* ------------------------------------------------------------
+ *  Unified typemap section
+ * ------------------------------------------------------------ */
+
+/* directors are supported in Python */
+#ifndef SWIG_DIRECTOR_TYPEMAPS
+#define SWIG_DIRECTOR_TYPEMAPS
+#endif
+
+
+/* Python types */
+#define SWIG_Object                     PyObject *
+#define VOID_Object                     SWIG_Py_Void()
+
+/* Python allows implicit conversion */
+#define %implicitconv_flag              $implicitconv 
+
+
+/* Overload of the output/constant/exception/dirout handling */
+
+/* append output */
+#define SWIG_AppendOutput(result, obj)  SWIG_Python_AppendOutput(result, obj)
+
+/* set constant */
+#if defined(SWIGPYTHON_BUILTIN)
+#define SWIG_SetConstant(name, obj) SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, name,obj) 
+#else
+#define SWIG_SetConstant(name, obj) SWIG_Python_SetConstant(d, name,obj) 
+#endif
+
+/* raise */
+#define SWIG_Raise(obj, type, desc)     SWIG_Python_Raise(obj, type, desc)
+
+/* Include the unified typemap library */
+%include <typemaps/swigtypemaps.swg>
+
+
+/*  ------------------------------------------------------------
+ *  Python extra typemaps / typemap overrides
+ * ------------------------------------------------------------ */
+
+/* Get the address of the 'python self' object */
+
+%typemap(in,numinputs=0,noblock=1) PyObject **PYTHON_SELF {
+  $1 = &$self;
+}
+
+
+/* Consttab, needed for callbacks, it should be removed later */
+
+%typemap(consttab) SWIGTYPE ((*)(ANY))
+{ SWIG_PY_POINTER, (char*)"$symname", 0, 0, (void *)($value), &$descriptor }
+%typemap(consttab) SWIGTYPE ((* const)(ANY)) = SWIGTYPE ((*)(ANY));
+
+%typemap(constcode) SWIGTYPE ((*)(ANY)) "";
+%typemap(constcode) SWIGTYPE ((* const)(ANY)) = SWIGTYPE ((*)(ANY));
+
+
+/* Smart Pointers */
+%typemap(out,noblock=1) const SWIGTYPE & SMARTPOINTER  {
+  $result = SWIG_NewPointerObj(%new_copy(*$1, $*ltype), $descriptor, SWIG_POINTER_OWN | %newpointer_flags);
+}
+
+%typemap(ret,noblock=1) const SWIGTYPE & SMARTPOINTER, SWIGTYPE SMARTPOINTER {
+  if ($result) {
+    PyObject *robj = PyObject_CallMethod($result, (char *)"__deref__", NULL);
+    if (robj && !PyErr_Occurred()) {
+      SwigPyObject_append((PyObject *) SWIG_Python_GetSwigThis($result), 
+			  (PyObject *) SWIG_Python_GetSwigThis(robj));
+      Py_DECREF(robj);
+    }
+  }
+}
+
diff --git a/share/swig/3.0.12/python/pyuserdir.swg b/share/swig/3.0.12/python/pyuserdir.swg
new file mode 100644
index 0000000..00aec07
--- /dev/null
+++ b/share/swig/3.0.12/python/pyuserdir.swg
@@ -0,0 +1,245 @@
+/* -------------------------------------------------------------------------
+ *  Special user directives
+ * ------------------------------------------------------------------------- */
+
+/* ------------------------------------------------------------------------- */
+
+/* shadow code */
+#define %shadow      %insert("shadow")
+#define %pythoncode  %insert("python")
+#define %pythonbegin %insert("pythonbegin")
+
+
+/* ------------------------------------------------------------------------- */
+/* 
+Use the "nondynamic" feature to make a wrapped class behave as a "nondynamic"
+one, ie, a python class that doesn't dynamically add new attributes.
+
+For example, for the class
+
+%pythonnondynamic A;
+struct A
+{
+  int a;
+  int b;
+};
+
+you will get:
+
+ aa = A()
+ aa.a = 1  # Ok
+ aa.b = 1  # Ok
+ aa.c = 3  # error
+
+Since nondynamic is a feature, if you use it like
+
+ %pythonnondynamic;
+
+it will make all the wrapped classes nondynamic ones.
+
+The implementation is based on this recipe:
+
+   http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/252158
+
+and works for modern (-modern) and plain python. We do not use __slots__, 
+so, it works with old python versions.
+
+*/
+
+#define %pythonnondynamic      %feature("python:nondynamic", "1")
+#define %nopythonnondynamic    %feature("python:nondynamic", "0")
+#define %clearpythonnondynamic %feature("python:nondynamic", "")
+#define %pythondynamic         %nopythonnondynamic
+
+
+/* ------------------------------------------------------------------------- */
+/*
+
+Use %pythonmaybecall to flag a method like __add__ or __radd__.  These
+don't produce an error when called, they just return NotImplemented.
+
+These methods "may be called" if needed.
+
+*/
+
+#define %pythonmaybecall      %feature("python:maybecall", "1") 
+#define %nopythonmaybecall    %feature("python:maybecall", "0")
+#define %clearpythonmaybecall %feature("python:maybecall", "")
+
+/* ------------------------------------------------------------------------- */
+/*
+  The %pythoncallback feature produce a more natural callback wrapper
+  than the %callback mechanism, ie, it uses the original name for
+  the callback and callable objects. 
+
+  Just use it as
+
+    %pythoncallback(1) foo;
+    int foo(int a);
+
+    %pythoncallback(1) A::foo;
+    struct A {
+     static int foo(int a);
+    };
+
+    int bar(int, int (*pf)(int));
+
+  then, you can use it as:
+
+   a = foo(1)
+   b = bar(2, foo)
+
+   c = A.foo(3)
+   d = bar(4, A.foo)
+
+
+   If you use it with a member method
+   %pythoncallback(1) A::foom;
+   struct A {
+      int foom(int a);
+   };
+
+   then you can use it as
+
+     r = a.foom(3)             # eval the method
+     mptr = A.foom_cb_ptr      # returns the callback pointer
+
+   where the '_cb_ptr' suffix is added for the callback pointer.
+
+*/
+
+#define %pythoncallback      %feature("python:callback")
+#define %nopythoncallback    %feature("python:callback","0")
+#define %clearpythoncallback %feature("python:callback","")
+
+/* ------------------------------------------------------------------------- */
+/*
+  Support for the old %callback directive name
+*/
+#ifdef %callback
+#undef %callback
+#endif
+
+#ifdef %nocallback
+#undef %nocallback
+#endif
+
+#ifdef %clearcallback
+#undef %clearcallback
+#endif
+
+#define %callback(x)     %feature("python:callback",`x`)
+#define %nocallback      %nopythoncallback
+#define %clearcallback   %clearpythoncallback
+
+/* ------------------------------------------------------------------------- */
+/*
+  Thread support - Advance control
+  
+*/
+
+#define %nothread           %feature("nothread")
+#define %thread             %feature("nothread","0")
+#define %clearnothread      %feature("nothread","")
+
+#define %nothreadblock      %feature("nothreadblock")
+#define %threadblock        %feature("nothreadblock","0")
+#define %clearnothreadblock %feature("nothreadblock","")
+
+#define %nothreadallow      %feature("nothreadallow")
+#define %threadallow        %feature("nothreadallow","0")
+#define %clearnothreadallow %feature("nothreadallow","")
+
+
+/* ------------------------------------------------------------------------- */
+/*
+  Implicit Conversion using the C++ constructor mechanism
+*/
+
+#define %implicitconv      %feature("implicitconv") 
+#define %noimplicitconv    %feature("implicitconv", "0")
+#define %clearimplicitconv %feature("implicitconv", "")
+
+
+/* ------------------------------------------------------------------------- */
+/*
+  Enable keywords paramaters
+*/
+
+#define %kwargs      %feature("kwargs") 
+#define %nokwargs    %feature("kwargs", "0")
+#define %clearkwargs %feature("kwargs", "")
+
+/* ------------------------------------------------------------------------- */
+/*
+  Add python code to the proxy/shadow code 
+  
+   %pythonprepend   - Add code before the C++ function is called
+   %pythonappend    - Add code after the C++ function is called
+*/
+
+#define %pythonprepend       %feature("pythonprepend") 
+#define %clearpythonprepend  %feature("pythonprepend","")
+
+#define %pythonappend         %feature("pythonappend") 
+#define %clearpythonappend    %feature("pythonappend","")
+
+
+/* ------------------------------------------------------------------------- */
+/* 
+   %extend_smart_pointer extend the smart pointer support.
+
+   For example, if you have a smart pointer as:
+	    
+     template <class Type> class RCPtr {
+     public:
+       ...
+       RCPtr(Type *p);
+   	Type * operator->() const;
+   	...
+     };
+     
+   you use the %extend_smart_pointer directive as:
+   
+     %extend_smart_pointer(RCPtr<A>);
+     %template(RCPtr_A)  RCPtr<A>;
+   
+   then, if you have something like:
+
+     RCPtr<A> make_ptr();
+     int foo(A *);
+
+   you can do the following:
+
+     a = make_ptr();
+     b = foo(a);
+
+   ie, swig will accept a RCPtr<A> object where a 'A *' is
+   expected.
+
+   Also, when using vectors
+   
+     %extend_smart_pointer(RCPtr<A>);
+     %template(RCPtr_A) RCPtr<A>;
+     %template(vector_A) std::vector<RCPtr<A> >;
+   	
+   you can type
+
+     a = A();
+     v = vector_A(2)
+     v[0] = a
+
+   ie, an 'A *' object is accepted, via implicit conversion, 
+   where a RCPtr<A> object is expected. Additionally
+
+     x = v[0]
+
+   returns (and sets 'x' as) a copy of v[0], making reference
+   counting possible and consistent.
+*/
+
+%define %extend_smart_pointer(Type...)
+%implicitconv Type;
+%apply const SWIGTYPE& SMARTPOINTER { const Type& };
+%apply SWIGTYPE SMARTPOINTER { Type };
+%enddef
diff --git a/share/swig/3.0.12/python/pywstrings.swg b/share/swig/3.0.12/python/pywstrings.swg
new file mode 100644
index 0000000..e646187
--- /dev/null
+++ b/share/swig/3.0.12/python/pywstrings.swg
@@ -0,0 +1,69 @@
+/* ------------------------------------------------------------
+ *  utility methods for wchar_t strings 
+ * ------------------------------------------------------------ */
+
+%{
+#if PY_VERSION_HEX >= 0x03020000
+# define SWIGPY_UNICODE_ARG(obj) ((PyObject*) (obj))
+#else
+# define SWIGPY_UNICODE_ARG(obj) ((PyUnicodeObject*) (obj))
+#endif
+%}
+
+%fragment("SWIG_AsWCharPtrAndSize","header",fragment="<wchar.h>",fragment="SWIG_pwchar_descriptor") {
+SWIGINTERN int
+SWIG_AsWCharPtrAndSize(PyObject *obj, wchar_t **cptr, size_t *psize, int *alloc)
+{
+  PyObject *tmp = 0;
+  int isunicode = PyUnicode_Check(obj);
+%#if PY_VERSION_HEX < 0x03000000 && !defined(SWIG_PYTHON_STRICT_UNICODE_WCHAR)
+  if (!isunicode && PyString_Check(obj)) {
+    obj = tmp = PyUnicode_FromObject(obj);
+    isunicode = 1;
+  }
+%#endif
+  if (isunicode) {
+    Py_ssize_t len = PyUnicode_GetSize(obj);
+    if (cptr) {
+      *cptr = %new_array(len + 1, wchar_t);
+      PyUnicode_AsWideChar(SWIGPY_UNICODE_ARG(obj), *cptr, len);
+      (*cptr)[len] = 0;
+    }
+    if (psize) *psize = (size_t) len + 1;
+    if (alloc) *alloc = cptr ? SWIG_NEWOBJ : 0;
+    Py_XDECREF(tmp);
+    return SWIG_OK;
+  } else {
+    swig_type_info* pwchar_descriptor = SWIG_pwchar_descriptor();
+    if (pwchar_descriptor) {
+      void * vptr = 0;
+      if (SWIG_ConvertPtr(obj, &vptr, pwchar_descriptor, 0) == SWIG_OK) {
+	if (cptr) *cptr = (wchar_t *)vptr;
+	if (psize) *psize = vptr ? (wcslen((wchar_t *)vptr) + 1) : 0;
+	return SWIG_OK;
+      }
+    }
+  }
+  return SWIG_TypeError;
+}
+}
+
+%fragment("SWIG_FromWCharPtrAndSize","header",fragment="<wchar.h>",fragment="SWIG_pwchar_descriptor") {
+SWIGINTERNINLINE PyObject *
+SWIG_FromWCharPtrAndSize(const wchar_t * carray, size_t size)
+{
+  if (carray) {
+    if (size > INT_MAX) {
+      swig_type_info* pwchar_descriptor = SWIG_pwchar_descriptor();
+      return pwchar_descriptor ? 
+	SWIG_InternalNewPointerObj(%const_cast(carray,wchar_t *), pwchar_descriptor, 0) : SWIG_Py_Void();
+    } else {
+      return PyUnicode_FromWideChar(carray, %numeric_cast(size, Py_ssize_t));
+    }
+  } else {
+    return SWIG_Py_Void();
+  }
+}
+}
+
+
diff --git a/share/swig/2.0.11/python/std_alloc.i b/share/swig/3.0.12/python/std_alloc.i
index 35dc051..35dc051 100644
--- a/share/swig/2.0.11/python/std_alloc.i
+++ b/share/swig/3.0.12/python/std_alloc.i
diff --git a/share/swig/3.0.12/python/std_array.i b/share/swig/3.0.12/python/std_array.i
new file mode 100644
index 0000000..a3de312
--- /dev/null
+++ b/share/swig/3.0.12/python/std_array.i
@@ -0,0 +1,91 @@
+/*
+  std::array
+*/
+
+%fragment("StdArrayTraits","header",fragment="StdSequenceTraits")
+%{
+  namespace swig {
+    template <class T, size_t N>
+    struct traits_asptr<std::array<T, N> >  {
+      static int asptr(PyObject *obj, std::array<T, N> **vec) {
+	return traits_asptr_stdseq<std::array<T, N> >::asptr(obj, vec);
+      }
+    };
+
+    template <class T, size_t N>
+    struct traits_from<std::array<T, N> > {
+      static PyObject *from(const std::array<T, N>& vec) {
+	return traits_from_stdseq<std::array<T, N> >::from(vec);
+      }
+    };
+
+    template <class SwigPySeq, class T, size_t N>
+    inline void
+    assign(const SwigPySeq& swigpyseq, std::array<T, N>* seq) {
+      if (swigpyseq.size() < seq->size())
+        throw std::invalid_argument("std::array cannot be expanded in size");
+      else if (swigpyseq.size() > seq->size())
+        throw std::invalid_argument("std::array cannot be reduced in size");
+      std::copy(swigpyseq.begin(), swigpyseq.end(), seq->begin());
+    }
+
+    template <class T, size_t N>
+    inline void
+    erase(std::array<T, N>* SWIGUNUSEDPARM(seq), const typename std::array<T, N>::iterator& SWIGUNUSEDPARM(position)) {
+      throw std::invalid_argument("std::array object does not support item deletion");
+    }
+
+    // Only limited slicing is supported as std::array is fixed in size
+    template <class T, size_t N, class Difference>
+    inline std::array<T, N>*
+    getslice(const std::array<T, N>* self, Difference i, Difference j, Py_ssize_t step) {
+      typedef std::array<T, N> Sequence;
+      typename Sequence::size_type size = self->size();
+      Difference ii = 0;
+      Difference jj = 0;
+      swig::slice_adjust(i, j, step, size, ii, jj);
+
+      if (step == 1 && ii == 0 && static_cast<typename Sequence::size_type>(jj) == size) {
+        Sequence *sequence = new Sequence();
+        std::copy(self->begin(), self->end(), sequence->begin());
+        return sequence;
+      } else if (step == -1 && static_cast<typename Sequence::size_type>(ii) == (size - 1) && jj == -1) {
+        Sequence *sequence = new Sequence();
+        std::copy(self->rbegin(), self->rend(), sequence->begin());
+        return sequence;
+      } else {
+        throw std::invalid_argument("std::array object only supports getting a slice that is the size of the array");
+      }
+    }
+
+    template <class T, size_t N, class Difference, class InputSeq>
+    inline void
+    setslice(std::array<T, N>* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) {
+      typedef std::array<T, N> Sequence;
+      typename Sequence::size_type size = self->size();
+      Difference ii = 0;
+      Difference jj = 0;
+      swig::slice_adjust(i, j, step, size, ii, jj, true);
+
+      if (step == 1 && ii == 0 && static_cast<typename Sequence::size_type>(jj) == size) {
+        std::copy(is.begin(), is.end(), self->begin());
+      } else if (step == -1 && static_cast<typename Sequence::size_type>(ii) == (size - 1) && jj == -1) {
+        std::copy(is.rbegin(), is.rend(), self->begin());
+      } else {
+        throw std::invalid_argument("std::array object only supports setting a slice that is the size of the array");
+      }
+    }
+
+    template <class T, size_t N, class Difference>
+    inline void
+    delslice(std::array<T, N>* SWIGUNUSEDPARM(self), Difference SWIGUNUSEDPARM(i), Difference SWIGUNUSEDPARM(j), Py_ssize_t SWIGUNUSEDPARM(step)) {
+      throw std::invalid_argument("std::array object does not support item deletion");
+    }
+  }
+%}
+
+#define %swig_array_methods(Type...) %swig_sequence_methods_non_resizable(Type)
+#define %swig_array_methods_val(Type...) %swig_sequence_methods_non_resizable_val(Type);
+
+%include <std/std_array.i>
+
diff --git a/share/swig/3.0.12/python/std_auto_ptr.i b/share/swig/3.0.12/python/std_auto_ptr.i
new file mode 100644
index 0000000..e310e00
--- /dev/null
+++ b/share/swig/3.0.12/python/std_auto_ptr.i
@@ -0,0 +1,17 @@
+/*
+    The typemaps here allow to handle functions returning std::auto_ptr<>,
+    which is the most common use of this type. If you have functions taking it
+    as parameter, these typemaps can't be used for them and you need to do
+    something else (e.g. use shared_ptr<> which SWIG supports fully).
+ */
+
+%define %auto_ptr(TYPE)
+%typemap (out) std::auto_ptr<TYPE > %{
+   %set_output(SWIG_NewPointerObj($1.release(), $descriptor(TYPE *), SWIG_POINTER_OWN | %newpointer_flags));
+%}
+%template() std::auto_ptr<TYPE >;
+%enddef
+
+namespace std {
+   template <class T> class auto_ptr {};
+} 
diff --git a/share/swig/2.0.11/python/std_basic_string.i b/share/swig/3.0.12/python/std_basic_string.i
index 7d3366d..7d3366d 100644
--- a/share/swig/2.0.11/python/std_basic_string.i
+++ b/share/swig/3.0.12/python/std_basic_string.i
diff --git a/share/swig/2.0.11/python/std_carray.i b/share/swig/3.0.12/python/std_carray.i
index 680d671..680d671 100644
--- a/share/swig/2.0.11/python/std_carray.i
+++ b/share/swig/3.0.12/python/std_carray.i
diff --git a/share/swig/2.0.11/python/std_char_traits.i b/share/swig/3.0.12/python/std_char_traits.i
index bf4e6c4..bf4e6c4 100644
--- a/share/swig/2.0.11/python/std_char_traits.i
+++ b/share/swig/3.0.12/python/std_char_traits.i
diff --git a/share/swig/3.0.12/python/std_common.i b/share/swig/3.0.12/python/std_common.i
new file mode 100644
index 0000000..6057662
--- /dev/null
+++ b/share/swig/3.0.12/python/std_common.i
@@ -0,0 +1,74 @@
+%include <std/std_except.i>
+%include <pystdcommon.swg>
+
+
+/*
+  Generate the traits for a 'primitive' type, such as 'double',
+  for which the SWIG_AsVal and SWIG_From methods are already defined.
+*/
+
+%define %traits_ptypen(Type...)
+  %fragment(SWIG_Traits_frag(Type),"header",
+	    fragment=SWIG_AsVal_frag(Type),
+	    fragment=SWIG_From_frag(Type),
+	    fragment="StdTraits") {
+namespace swig {
+  template <> struct traits< Type > {
+    typedef value_category category;
+    static const char* type_name() { return  #Type; }
+  };
+  template <>  struct traits_asval< Type > {
+    typedef Type value_type;
+    static int asval(PyObject *obj, value_type *val) {
+      return SWIG_AsVal(Type)(obj, val);
+    }
+  };
+  template <>  struct traits_from< Type > {
+    typedef Type value_type;
+    static PyObject *from(const value_type& val) {
+      return SWIG_From(Type)(val);
+    }
+  };
+}
+}
+%enddef
+
+/* Traits for enums. This is bit of a sneaky trick needed because a generic template specialization of enums
+   is not possible (unless using template meta-programming which SWIG doesn't support because of the explicit
+   instantiations required using %template). The STL containers define the 'front' method and the typemap
+   below is used whenever the front method is wrapped returning an enum. This typemap simply picks up the
+   standard enum typemap, but additionally drags in a fragment containing the traits_asval and traits_from
+   required in the generated code for enums. */
+
+%define %traits_enum(Type...)
+  %fragment("SWIG_Traits_enum_"{Type},"header",
+	    fragment=SWIG_AsVal_frag(int),
+	    fragment=SWIG_From_frag(int),
+	    fragment="StdTraits") {
+namespace swig {
+  template <>  struct traits_asval< Type > {
+    typedef Type value_type;
+    static int asval(PyObject *obj, value_type *val) {
+      return SWIG_AsVal(int)(obj, (int *)val);
+    }
+  };
+  template <>  struct traits_from< Type > {
+    typedef Type value_type;
+    static PyObject *from(const value_type& val) {
+      return SWIG_From(int)((int)val);
+    }
+  };
+}
+}
+%typemap(out, fragment="SWIG_Traits_enum_"{Type}) const enum SWIGTYPE& front %{$typemap(out, const enum SWIGTYPE&)%}
+%enddef
+
+
+%include <std/std_common.i>
+
+//
+// Generates the traits for all the known primitive
+// C++ types (int, double, ...)
+//
+%apply_cpptypes(%traits_ptypen);
+
diff --git a/share/swig/2.0.11/python/std_complex.i b/share/swig/3.0.12/python/std_complex.i
index 4e8fed3..4e8fed3 100644
--- a/share/swig/2.0.11/python/std_complex.i
+++ b/share/swig/3.0.12/python/std_complex.i
diff --git a/share/swig/2.0.11/python/std_container.i b/share/swig/3.0.12/python/std_container.i
index d24c157..d24c157 100644
--- a/share/swig/2.0.11/python/std_container.i
+++ b/share/swig/3.0.12/python/std_container.i
diff --git a/share/swig/2.0.11/python/std_deque.i b/share/swig/3.0.12/python/std_deque.i
index b193756..b193756 100644
--- a/share/swig/2.0.11/python/std_deque.i
+++ b/share/swig/3.0.12/python/std_deque.i
diff --git a/share/swig/2.0.11/ruby/std_except.i b/share/swig/3.0.12/python/std_except.i
index af98428..af98428 100644
--- a/share/swig/2.0.11/ruby/std_except.i
+++ b/share/swig/3.0.12/python/std_except.i
diff --git a/share/swig/2.0.11/python/std_ios.i b/share/swig/3.0.12/python/std_ios.i
index aa6f099..aa6f099 100644
--- a/share/swig/2.0.11/python/std_ios.i
+++ b/share/swig/3.0.12/python/std_ios.i
diff --git a/share/swig/2.0.11/python/std_iostream.i b/share/swig/3.0.12/python/std_iostream.i
index 43d6b0c..43d6b0c 100644
--- a/share/swig/2.0.11/python/std_iostream.i
+++ b/share/swig/3.0.12/python/std_iostream.i
diff --git a/share/swig/2.0.11/python/std_list.i b/share/swig/3.0.12/python/std_list.i
index baf66d9..baf66d9 100644
--- a/share/swig/2.0.11/python/std_list.i
+++ b/share/swig/3.0.12/python/std_list.i
diff --git a/share/swig/3.0.12/python/std_map.i b/share/swig/3.0.12/python/std_map.i
new file mode 100644
index 0000000..f61f79c
--- /dev/null
+++ b/share/swig/3.0.12/python/std_map.i
@@ -0,0 +1,310 @@
+/*
+  Maps
+*/
+
+%fragment("StdMapCommonTraits","header",fragment="StdSequenceTraits")
+{
+  namespace swig {
+    template <class ValueType>
+    struct from_key_oper 
+    {
+      typedef const ValueType& argument_type;
+      typedef  PyObject *result_type;
+      result_type operator()(argument_type v) const
+      {
+	return swig::from(v.first);
+      }
+    };
+
+    template <class ValueType>
+    struct from_value_oper 
+    {
+      typedef const ValueType& argument_type;
+      typedef  PyObject *result_type;
+      result_type operator()(argument_type v) const
+      {
+	return swig::from(v.second);
+      }
+    };
+
+    template<class OutIterator, class FromOper, class ValueType = typename OutIterator::value_type>
+    struct SwigPyMapIterator_T : SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper>
+    {
+      SwigPyMapIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
+	: SwigPyIteratorClosed_T<OutIterator,ValueType,FromOper>(curr, first, last, seq)
+      {
+      }
+    };
+
+
+    template<class OutIterator,
+	     class FromOper = from_key_oper<typename OutIterator::value_type> >
+    struct SwigPyMapKeyIterator_T : SwigPyMapIterator_T<OutIterator, FromOper>
+    {
+      SwigPyMapKeyIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
+	: SwigPyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
+      {
+      }
+    };
+
+    template<typename OutIter>
+    inline SwigPyIterator*
+    make_output_key_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
+    {
+      return new SwigPyMapKeyIterator_T<OutIter>(current, begin, end, seq);
+    }
+
+    template<class OutIterator,
+	     class FromOper = from_value_oper<typename OutIterator::value_type> >
+    struct SwigPyMapValueITerator_T : SwigPyMapIterator_T<OutIterator, FromOper>
+    {
+      SwigPyMapValueITerator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
+	: SwigPyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
+      {
+      }
+    };
+    
+
+    template<typename OutIter>
+    inline SwigPyIterator*
+    make_output_value_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
+    {
+      return new SwigPyMapValueITerator_T<OutIter>(current, begin, end, seq);
+    }
+  }
+}
+
+%fragment("StdMapTraits","header",fragment="StdMapCommonTraits")
+{
+  namespace swig {
+    template <class SwigPySeq, class K, class T, class Compare, class Alloc >
+    inline void
+    assign(const SwigPySeq& swigpyseq, std::map<K,T,Compare,Alloc > *map) {
+      typedef typename std::map<K,T,Compare,Alloc >::value_type value_type;
+      typename SwigPySeq::const_iterator it = swigpyseq.begin();
+      for (;it != swigpyseq.end(); ++it) {
+	map->insert(value_type(it->first, it->second));
+      }
+    }
+
+    template <class K, class T, class Compare, class Alloc>
+    struct traits_asptr<std::map<K,T,Compare,Alloc > >  {
+      typedef std::map<K,T,Compare,Alloc > map_type;
+      static int asptr(PyObject *obj, map_type **val) {
+	int res = SWIG_ERROR;
+	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+	if (PyDict_Check(obj)) {
+	  SwigVar_PyObject items = PyObject_CallMethod(obj,(char *)"items",NULL);
+%#if PY_VERSION_HEX >= 0x03000000
+          /* In Python 3.x the ".items()" method returns a dict_items object */
+          items = PySequence_Fast(items, ".items() didn't return a sequence!");
+%#endif
+	  res = traits_asptr_stdseq<map_type, std::pair<K, T> >::asptr(items, val);
+	} else {
+	  map_type *p;
+	  swig_type_info *descriptor = swig::type_info<map_type>();
+	  res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
+	  if (SWIG_IsOK(res) && val)  *val = p;
+	}
+	SWIG_PYTHON_THREAD_END_BLOCK;
+	return res;
+      }      
+    };
+      
+    template <class K, class T, class Compare, class Alloc >
+    struct traits_from<std::map<K,T,Compare,Alloc > >  {
+      typedef std::map<K,T,Compare,Alloc > map_type;
+      typedef typename map_type::const_iterator const_iterator;
+      typedef typename map_type::size_type size_type;
+
+      static PyObject *asdict(const map_type& map) {
+	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+	size_type size = map.size();
+	Py_ssize_t pysize = (size <= (size_type) INT_MAX) ? (Py_ssize_t) size : -1;
+	if (pysize < 0) {
+	  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
+	  SWIG_PYTHON_THREAD_END_BLOCK;
+	  return NULL;
+	}
+	PyObject *obj = PyDict_New();
+	for (const_iterator i= map.begin(); i!= map.end(); ++i) {
+	  swig::SwigVar_PyObject key = swig::from(i->first);
+	  swig::SwigVar_PyObject val = swig::from(i->second);
+	  PyDict_SetItem(obj, key, val);
+	}
+	SWIG_PYTHON_THREAD_END_BLOCK;
+	return obj;
+      }
+                
+      static PyObject *from(const map_type& map) {
+	swig_type_info *desc = swig::type_info<map_type>();
+	if (desc && desc->clientdata) {
+	  return SWIG_InternalNewPointerObj(new map_type(map), desc, SWIG_POINTER_OWN);
+	} else {
+	  return asdict(map);
+	}
+      }
+    };
+  }
+}
+
+%define %swig_map_common(Map...)
+  %swig_sequence_iterator(Map);
+  %swig_container_methods(Map)
+
+#if defined(SWIGPYTHON_BUILTIN)
+  %feature("python:slot", "mp_length", functype="lenfunc") __len__;
+  %feature("python:slot", "mp_subscript", functype="binaryfunc") __getitem__;
+  %feature("python:slot", "tp_iter", functype="getiterfunc") key_iterator;
+
+  %extend {
+    %newobject iterkeys(PyObject **PYTHON_SELF);
+    swig::SwigPyIterator* iterkeys(PyObject **PYTHON_SELF) {
+      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+    }
+      
+    %newobject itervalues(PyObject **PYTHON_SELF);
+    swig::SwigPyIterator* itervalues(PyObject **PYTHON_SELF) {
+      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+    }
+
+    %newobject iteritems(PyObject **PYTHON_SELF);
+    swig::SwigPyIterator* iteritems(PyObject **PYTHON_SELF) {
+      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+    }
+  }
+
+#else
+  %extend {
+    %pythoncode %{def __iter__(self):
+    return self.key_iterator()%}
+    %pythoncode %{def iterkeys(self):
+    return self.key_iterator()%}
+    %pythoncode %{def itervalues(self):
+    return self.value_iterator()%}
+    %pythoncode %{def iteritems(self):
+    return self.iterator()%}
+  }
+#endif
+
+  %extend {
+    mapped_type const & __getitem__(const key_type& key) throw (std::out_of_range) {
+      Map::const_iterator i = self->find(key);
+      if (i != self->end())
+	return i->second;
+      else
+	throw std::out_of_range("key not found");
+    }
+
+    void __delitem__(const key_type& key) throw (std::out_of_range) {
+      Map::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 key_type& key) const {
+      Map::const_iterator i = self->find(key);
+      return i != self->end();
+    }
+    
+    PyObject* keys() {
+      Map::size_type size = self->size();
+      Py_ssize_t pysize = (size <= (Map::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
+      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+      if (pysize < 0) {
+	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
+	SWIG_PYTHON_THREAD_END_BLOCK;
+	return NULL;
+      }
+      PyObject* keyList = PyList_New(pysize);
+      Map::const_iterator i = self->begin();
+      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
+	PyList_SET_ITEM(keyList, j, swig::from(i->first));
+      }
+      SWIG_PYTHON_THREAD_END_BLOCK;
+      return keyList;
+    }
+    
+    PyObject* values() {
+      Map::size_type size = self->size();
+      Py_ssize_t pysize = (size <= (Map::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
+      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+      if (pysize < 0) {
+	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
+	SWIG_PYTHON_THREAD_END_BLOCK;
+	return NULL;
+      }
+      PyObject* valList = PyList_New(pysize);
+      Map::const_iterator i = self->begin();
+      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
+	PyList_SET_ITEM(valList, j, swig::from(i->second));
+      }
+      SWIG_PYTHON_THREAD_END_BLOCK;
+      return valList;
+    }
+    
+    PyObject* items() {
+      Map::size_type size = self->size();
+      Py_ssize_t pysize = (size <= (Map::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
+      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+      if (pysize < 0) {
+	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
+	SWIG_PYTHON_THREAD_END_BLOCK;
+	return NULL;
+      }    
+      PyObject* itemList = PyList_New(pysize);
+      Map::const_iterator i = self->begin();
+      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
+	PyList_SET_ITEM(itemList, j, swig::from(*i));
+      }
+      SWIG_PYTHON_THREAD_END_BLOCK;
+      return itemList;
+    }
+    
+    // Python 2.2 methods
+    bool __contains__(const key_type& key) {
+      return self->find(key) != self->end();
+    }
+
+    %newobject key_iterator(PyObject **PYTHON_SELF);
+    swig::SwigPyIterator* key_iterator(PyObject **PYTHON_SELF) {
+      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+    }
+
+    %newobject value_iterator(PyObject **PYTHON_SELF);
+    swig::SwigPyIterator* value_iterator(PyObject **PYTHON_SELF) {
+      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+    }
+  }
+
+%enddef
+
+%define %swig_map_methods(Map...)
+  %swig_map_common(Map)
+
+#if defined(SWIGPYTHON_BUILTIN)
+  %feature("python:slot", "mp_ass_subscript", functype="objobjargproc") __setitem__;
+#endif
+
+  %extend {
+    // This will be called through the mp_ass_subscript slot to delete an entry.
+    void __setitem__(const key_type& key) {
+      self->erase(key);
+    }
+
+    void __setitem__(const key_type& key, const mapped_type& x) throw (std::out_of_range) {
+      (*self)[key] = x;
+    }
+
+    PyObject* asdict() {
+      return swig::traits_from< Map >::asdict(*self);
+    }
+  }
+
+
+%enddef
+
+
+%include <std/std_map.i>
diff --git a/share/swig/3.0.12/python/std_multimap.i b/share/swig/3.0.12/python/std_multimap.i
new file mode 100644
index 0000000..3209fb0
--- /dev/null
+++ b/share/swig/3.0.12/python/std_multimap.i
@@ -0,0 +1,79 @@
+/*
+  Multimaps
+*/
+%include <std_map.i>
+
+%fragment("StdMultimapTraits","header",fragment="StdMapCommonTraits")
+{
+  namespace swig {
+    template <class SwigPySeq, class K, class T >
+    inline void 
+    assign(const SwigPySeq& swigpyseq, std::multimap<K,T > *multimap) {
+      typedef typename std::multimap<K,T>::value_type value_type;
+      typename SwigPySeq::const_iterator it = swigpyseq.begin();
+      for (;it != swigpyseq.end(); ++it) {
+	multimap->insert(value_type(it->first, it->second));
+      }
+    }
+
+    template <class K, class T>
+    struct traits_asptr<std::multimap<K,T> >  {
+      typedef std::multimap<K,T> multimap_type;
+      static int asptr(PyObject *obj, std::multimap<K,T> **val) {
+	int res = SWIG_ERROR;
+	if (PyDict_Check(obj)) {
+	  SwigVar_PyObject items = PyObject_CallMethod(obj,(char *)"items",NULL);
+	  return traits_asptr_stdseq<std::multimap<K,T>, std::pair<K, T> >::asptr(items, val);
+	} else {
+	  multimap_type *p;
+	  swig_type_info *descriptor = swig::type_info<multimap_type>();
+	  res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
+	  if (SWIG_IsOK(res) && val)  *val = p;
+	}
+	return res;
+      }
+    };
+      
+    template <class K, class T >
+    struct traits_from<std::multimap<K,T> >  {
+      typedef std::multimap<K,T> multimap_type;
+      typedef typename multimap_type::const_iterator const_iterator;
+      typedef typename multimap_type::size_type size_type;
+            
+      static PyObject *from(const multimap_type& multimap) {
+	swig_type_info *desc = swig::type_info<multimap_type>();
+	if (desc && desc->clientdata) {
+	  return SWIG_InternalNewPointerObj(new multimap_type(multimap), desc, SWIG_POINTER_OWN);
+	} else {
+	  size_type size = multimap.size();
+	  Py_ssize_t pysize = (size <= (size_type) INT_MAX) ? (Py_ssize_t) size : -1;
+	  if (pysize < 0) {
+	    SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+	    PyErr_SetString(PyExc_OverflowError, "multimap size not valid in python");
+	    SWIG_PYTHON_THREAD_END_BLOCK;
+	    return NULL;
+	  }
+	  PyObject *obj = PyDict_New();
+	  for (const_iterator i= multimap.begin(); i!= multimap.end(); ++i) {
+	    swig::SwigVar_PyObject key = swig::from(i->first);
+	    swig::SwigVar_PyObject val = swig::from(i->second);
+	    PyDict_SetItem(obj, key, val);
+	  }
+	  return obj;
+	}
+      }
+    };
+  }
+}
+
+%define %swig_multimap_methods(Type...) 
+  %swig_map_common(Type);
+  %extend {
+    void __setitem__(const key_type& key, const mapped_type& x) throw (std::out_of_range) {
+      self->insert(Type::value_type(key,x));
+    }
+  }
+%enddef
+
+%include <std/std_multimap.i>
+
diff --git a/share/swig/2.0.11/python/std_multiset.i b/share/swig/3.0.12/python/std_multiset.i
index ac43033..ac43033 100644
--- a/share/swig/2.0.11/python/std_multiset.i
+++ b/share/swig/3.0.12/python/std_multiset.i
diff --git a/share/swig/3.0.12/python/std_pair.i b/share/swig/3.0.12/python/std_pair.i
new file mode 100644
index 0000000..172572b
--- /dev/null
+++ b/share/swig/3.0.12/python/std_pair.i
@@ -0,0 +1,206 @@
+/*
+  Pairs
+*/
+%include <pystdcommon.swg>
+
+//#define SWIG_STD_PAIR_ASVAL
+
+%fragment("StdPairTraits","header",fragment="StdTraits") {
+  namespace swig {
+#ifdef SWIG_STD_PAIR_ASVAL
+    template <class T, class U >
+    struct traits_asval<std::pair<T,U> >  {
+      typedef std::pair<T,U> value_type;
+
+      static int get_pair(PyObject* first, PyObject* second,
+			  std::pair<T,U> *val)
+      {
+	if (val) {
+	  T *pfirst = &(val->first);
+	  int res1 = swig::asval((PyObject*)first, pfirst);
+	  if (!SWIG_IsOK(res1)) return res1;
+	  U *psecond = &(val->second);
+	  int res2 = swig::asval((PyObject*)second, psecond);
+	  if (!SWIG_IsOK(res2)) return res2;
+	  return res1 > res2 ? res1 : res2;
+	} else {
+	  T *pfirst = 0;
+	  int res1 = swig::asval((PyObject*)first, 0);
+	  if (!SWIG_IsOK(res1)) return res1;
+	  U *psecond = 0;
+	  int res2 = swig::asval((PyObject*)second, psecond);
+	  if (!SWIG_IsOK(res2)) return res2;
+	  return res1 > res2 ? res1 : res2;
+	}
+      }
+
+      static int asval(PyObject *obj, std::pair<T,U> *val) {
+	int res = SWIG_ERROR;
+	if (PyTuple_Check(obj)) {
+	  if (PyTuple_GET_SIZE(obj) == 2) {
+	    res = get_pair(PyTuple_GET_ITEM(obj,0),PyTuple_GET_ITEM(obj,1), val);
+	  }
+	} else if (PySequence_Check(obj)) {
+	  if (PySequence_Size(obj) == 2) {
+	    swig::SwigVar_PyObject first = PySequence_GetItem(obj,0);
+	    swig::SwigVar_PyObject second = PySequence_GetItem(obj,1);
+	    res = get_pair(first, second, val);
+	  }
+	} else {
+	  value_type *p;
+	  swig_type_info *descriptor = swig::type_info<value_type>();
+	  res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
+	  if (SWIG_IsOK(res) && val)  *val = *p;
+	}
+	return res;
+      }
+    };
+
+#else
+    template <class T, class U >
+    struct traits_asptr<std::pair<T,U> >  {
+      typedef std::pair<T,U> value_type;
+
+      static int get_pair(PyObject* first, PyObject* second,
+			  std::pair<T,U> **val) 
+      {
+	if (val) {
+	  value_type *vp = %new_instance(std::pair<T,U>);
+	  T *pfirst = &(vp->first);
+	  int res1 = swig::asval((PyObject*)first, pfirst);
+	  if (!SWIG_IsOK(res1)) {
+	    %delete(vp);
+	    return res1;
+	  }
+	  U *psecond = &(vp->second);
+	  int res2 = swig::asval((PyObject*)second, psecond);
+	  if (!SWIG_IsOK(res2)) {
+	    %delete(vp);
+	    return res2;
+	  }
+	  *val = vp;
+	  return SWIG_AddNewMask(res1 > res2 ? res1 : res2);
+	} else {
+	  T *pfirst = 0;
+	  int res1 = swig::asval((PyObject*)first, pfirst);
+	  if (!SWIG_IsOK(res1)) return res1;
+	  U *psecond = 0;
+	  int res2 = swig::asval((PyObject*)second, psecond);
+	  if (!SWIG_IsOK(res2)) return res2;
+	  return res1 > res2 ? res1 : res2;
+	}
+      }
+
+      static int asptr(PyObject *obj, std::pair<T,U> **val) {
+	int res = SWIG_ERROR;
+	if (PyTuple_Check(obj)) {
+	  if (PyTuple_GET_SIZE(obj) == 2) {
+	    res = get_pair(PyTuple_GET_ITEM(obj,0),PyTuple_GET_ITEM(obj,1), val);
+	  }
+	} else if (PySequence_Check(obj)) {
+	  if (PySequence_Size(obj) == 2) {
+	    swig::SwigVar_PyObject first = PySequence_GetItem(obj,0);
+	    swig::SwigVar_PyObject second = PySequence_GetItem(obj,1);
+	    res = get_pair(first, second, val);
+	  }
+	} else {
+	  value_type *p;
+	  swig_type_info *descriptor = swig::type_info<value_type>();
+	  res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
+	  if (SWIG_IsOK(res) && val)  *val = p;
+	}
+	return res;
+      }
+    };
+
+#endif
+    template <class T, class U >
+    struct traits_from<std::pair<T,U> >   {
+      static PyObject *from(const std::pair<T,U>& val) {
+	PyObject* obj = PyTuple_New(2);
+	PyTuple_SetItem(obj,0,swig::from(val.first));
+	PyTuple_SetItem(obj,1,swig::from(val.second));
+	return obj;
+      }
+    };
+  }
+
+#if defined(SWIGPYTHON_BUILTIN)
+SWIGINTERN Py_ssize_t
+SwigPython_std_pair_len (PyObject *a)
+{
+    return 2;
+}
+
+SWIGINTERN PyObject*
+SwigPython_std_pair_repr (PyObject *o)
+{
+    PyObject *tuple = PyTuple_New(2);
+    assert(tuple);
+    PyTuple_SET_ITEM(tuple, 0, PyObject_GetAttrString(o, (char*) "first"));
+    PyTuple_SET_ITEM(tuple, 1, PyObject_GetAttrString(o, (char*) "second"));
+    PyObject *result = PyObject_Repr(tuple);
+    Py_DECREF(tuple);
+    return result;
+}
+
+SWIGINTERN PyObject*
+SwigPython_std_pair_getitem (PyObject *a, Py_ssize_t b)
+{
+    PyObject *result = PyObject_GetAttrString(a, b % 2 ? (char*) "second" : (char*) "first");
+    return result;
+}
+
+SWIGINTERN int
+SwigPython_std_pair_setitem (PyObject *a, Py_ssize_t b, PyObject *c)
+{
+    int result = PyObject_SetAttrString(a, b % 2 ? (char*) "second" : (char*) "first", c);
+    return result;
+}
+#endif
+
+}
+
+%feature("python:sq_length") std::pair "SwigPython_std_pair_len";
+%feature("python:sq_length") std::pair<T*,U> "SwigPython_std_pair_len";
+%feature("python:sq_length") std::pair<T,U*> "SwigPython_std_pair_len";
+%feature("python:sq_length") std::pair<T*,U*> "SwigPython_std_pair_len";
+
+%feature("python:tp_repr") std::pair "SwigPython_std_pair_repr";
+%feature("python:tp_repr") std::pair<T*,U> "SwigPython_std_pair_repr";
+%feature("python:tp_repr") std::pair<T,U*> "SwigPython_std_pair_repr";
+%feature("python:tp_repr") std::pair<T*,U*> "SwigPython_std_pair_repr";
+
+%feature("python:sq_item") std::pair "SwigPython_std_pair_getitem";
+%feature("python:sq_item") std::pair<T*,U> "SwigPython_std_pair_getitem";
+%feature("python:sq_item") std::pair<T,U*> "SwigPython_std_pair_getitem";
+%feature("python:sq_item") std::pair<T*,U*> "SwigPython_std_pair_getitem";
+
+%feature("python:sq_ass_item") std::pair "SwigPython_std_pair_setitem";
+%feature("python:sq_ass_item") std::pair<T*,U> "SwigPython_std_pair_setitem";
+%feature("python:sq_ass_item") std::pair<T,U*> "SwigPython_std_pair_setitem";
+%feature("python:sq_ass_item") std::pair<T*,U*> "SwigPython_std_pair_setitem";
+
+%define %swig_pair_methods(pair...)
+#if !defined(SWIGPYTHON_BUILTIN)
+%extend {      
+%pythoncode %{def __len__(self):
+    return 2
+def __repr__(self):
+    return str((self.first, self.second))
+def __getitem__(self, index): 
+    if not (index % 2):
+        return self.first
+    else:
+        return self.second
+def __setitem__(self, index, val):
+    if not (index % 2):
+        self.first = val
+    else:
+        self.second = val%}
+}
+#endif
+%enddef
+
+%include <std/std_pair.i>
+
diff --git a/share/swig/2.0.11/python/std_set.i b/share/swig/3.0.12/python/std_set.i
index 53f97e4..53f97e4 100644
--- a/share/swig/2.0.11/python/std_set.i
+++ b/share/swig/3.0.12/python/std_set.i
diff --git a/share/swig/3.0.12/python/std_shared_ptr.i b/share/swig/3.0.12/python/std_shared_ptr.i
new file mode 100644
index 0000000..df87367
--- /dev/null
+++ b/share/swig/3.0.12/python/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/python/std_sstream.i b/share/swig/3.0.12/python/std_sstream.i
index 6647df8..6647df8 100644
--- a/share/swig/2.0.11/python/std_sstream.i
+++ b/share/swig/3.0.12/python/std_sstream.i
diff --git a/share/swig/2.0.11/python/std_streambuf.i b/share/swig/3.0.12/python/std_streambuf.i
index 44b9bb4..44b9bb4 100644
--- a/share/swig/2.0.11/python/std_streambuf.i
+++ b/share/swig/3.0.12/python/std_streambuf.i
diff --git a/share/swig/3.0.12/python/std_string.i b/share/swig/3.0.12/python/std_string.i
new file mode 100644
index 0000000..dc1378a
--- /dev/null
+++ b/share/swig/3.0.12/python/std_string.i
@@ -0,0 +1 @@
+%include <typemaps/std_string.swg>
diff --git a/share/swig/3.0.12/python/std_unordered_map.i b/share/swig/3.0.12/python/std_unordered_map.i
new file mode 100644
index 0000000..894840c
--- /dev/null
+++ b/share/swig/3.0.12/python/std_unordered_map.i
@@ -0,0 +1,259 @@
+/*
+  Unordered Maps
+*/
+
+%fragment("StdMapTraits","header",fragment="StdSequenceTraits")
+{
+  namespace swig {
+    template <class SwigPySeq, class K, class T >
+    inline void
+    assign(const SwigPySeq& swigpyseq, std::unordered_map<K,T > *unordered_map) {
+      typedef typename std::unordered_map<K,T>::value_type value_type;
+      typename SwigPySeq::const_iterator it = swigpyseq.begin();
+      for (;it != swigpyseq.end(); ++it) {
+	unordered_map->insert(value_type(it->first, it->second));
+      }
+    }
+
+    template <class K, class T>
+    struct traits_reserve<std::unordered_map<K,T> > {
+      static void reserve(std::unordered_map<K,T> &seq, typename std::unordered_map<K,T>::size_type n) {
+        seq.reserve(n);
+      }
+    };
+
+    template <class K, class T>
+    struct traits_asptr<std::unordered_map<K,T> >  {
+      typedef std::unordered_map<K,T> unordered_map_type;
+      static int asptr(PyObject *obj, unordered_map_type **val) {
+	int res = SWIG_ERROR;
+	if (PyDict_Check(obj)) {
+	  SwigVar_PyObject items = PyObject_CallMethod(obj,(char *)"items",NULL);
+%#if PY_VERSION_HEX >= 0x03000000
+          /* In Python 3.x the ".items()" method return a dict_items object */
+          items = PySequence_Fast(items, ".items() havn't returned a sequence!");
+%#endif
+	  res = traits_asptr_stdseq<std::unordered_map<K,T>, std::pair<K, T> >::asptr(items, val);
+	} else {
+	  unordered_map_type *p;
+	  swig_type_info *descriptor = swig::type_info<unordered_map_type>();
+	  res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
+	  if (SWIG_IsOK(res) && val)  *val = p;
+	}
+	return res;
+      }      
+    };
+      
+    template <class K, class T >
+    struct traits_from<std::unordered_map<K,T> >  {
+      typedef std::unordered_map<K,T> unordered_map_type;
+      typedef typename unordered_map_type::const_iterator const_iterator;
+      typedef typename unordered_map_type::size_type size_type;
+            
+      static PyObject *from(const unordered_map_type& unordered_map) {
+	swig_type_info *desc = swig::type_info<unordered_map_type>();
+	if (desc && desc->clientdata) {
+	  return SWIG_NewPointerObj(new unordered_map_type(unordered_map), desc, SWIG_POINTER_OWN);
+	} else {
+	  size_type size = unordered_map.size();
+	  Py_ssize_t pysize = (size <= (size_type) INT_MAX) ? (Py_ssize_t) size : -1;
+	  if (pysize < 0) {
+	    SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+	    PyErr_SetString(PyExc_OverflowError, "unordered_map size not valid in python");
+	    SWIG_PYTHON_THREAD_END_BLOCK;
+	    return NULL;
+	  }
+	  PyObject *obj = PyDict_New();
+	  for (const_iterator i= unordered_map.begin(); i!= unordered_map.end(); ++i) {
+	    swig::SwigVar_PyObject key = swig::from(i->first);
+	    swig::SwigVar_PyObject val = swig::from(i->second);
+	    PyDict_SetItem(obj, key, val);
+	  }
+	  return obj;
+	}
+      }
+    };
+
+    template <class ValueType>
+    struct from_key_oper 
+    {
+      typedef const ValueType& argument_type;
+      typedef  PyObject *result_type;
+      result_type operator()(argument_type v) const
+      {
+	return swig::from(v.first);
+      }
+    };
+
+    template <class ValueType>
+    struct from_value_oper 
+    {
+      typedef const ValueType& argument_type;
+      typedef  PyObject *result_type;
+      result_type operator()(argument_type v) const
+      {
+	return swig::from(v.second);
+      }
+    };
+
+    template<class OutIterator, class FromOper, class ValueType = typename OutIterator::value_type>
+    struct SwigPyMapIterator_T : SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper>
+    {
+      SwigPyMapIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
+	: SwigPyIteratorClosed_T<OutIterator,ValueType,FromOper>(curr, first, last, seq)
+      {
+      }
+    };
+
+
+    template<class OutIterator,
+	     class FromOper = from_key_oper<typename OutIterator::value_type> >
+    struct SwigPyMapKeyIterator_T : SwigPyMapIterator_T<OutIterator, FromOper>
+    {
+      SwigPyMapKeyIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
+	: SwigPyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
+      {
+      }
+    };
+
+    template<typename OutIter>
+    inline SwigPyIterator*
+    make_output_key_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
+    {
+      return new SwigPyMapKeyIterator_T<OutIter>(current, begin, end, seq);
+    }
+
+    template<class OutIterator,
+	     class FromOper = from_value_oper<typename OutIterator::value_type> >
+    struct SwigPyMapValueITerator_T : SwigPyMapIterator_T<OutIterator, FromOper>
+    {
+      SwigPyMapValueITerator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
+	: SwigPyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
+      {
+      }
+    };
+    
+
+    template<typename OutIter>
+    inline SwigPyIterator*
+    make_output_value_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
+    {
+      return new SwigPyMapValueITerator_T<OutIter>(current, begin, end, seq);
+    }
+  }
+}
+
+%define %swig_unordered_map_common(Map...)
+  %swig_sequence_iterator(Map);
+  %swig_container_methods(Map)
+
+  %extend {
+    mapped_type __getitem__(const key_type& key) const throw (std::out_of_range) {
+      Map::const_iterator i = self->find(key);
+      if (i != self->end())
+	return i->second;
+      else
+	throw std::out_of_range("key not found");
+    }
+    
+    void __delitem__(const key_type& key) throw (std::out_of_range) {
+      Map::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 key_type& key) const {
+      Map::const_iterator i = self->find(key);
+      return i != self->end();
+    }
+    
+    PyObject* keys() {
+      Map::size_type size = self->size();
+      Py_ssize_t pysize = (size <= (Map::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
+      if (pysize < 0) {
+	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+	PyErr_SetString(PyExc_OverflowError, "unordered_map size not valid in python");
+	SWIG_PYTHON_THREAD_END_BLOCK;
+	return NULL;
+      }
+      PyObject* keyList = PyList_New(pysize);
+      Map::const_iterator i = self->begin();
+      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
+	PyList_SET_ITEM(keyList, j, swig::from(i->first));
+      }
+      return keyList;
+    }
+    
+    PyObject* values() {
+      Map::size_type size = self->size();
+      Py_ssize_t pysize = (size <= (Map::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
+      if (pysize < 0) {
+	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+	PyErr_SetString(PyExc_OverflowError, "unordered_map size not valid in python");
+	SWIG_PYTHON_THREAD_END_BLOCK;
+	return NULL;
+      }
+      PyObject* valList = PyList_New(pysize);
+      Map::const_iterator i = self->begin();
+      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
+	PyList_SET_ITEM(valList, j, swig::from(i->second));
+      }
+      return valList;
+    }
+    
+    PyObject* items() {
+      Map::size_type size = self->size();
+      Py_ssize_t pysize = (size <= (Map::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
+      if (pysize < 0) {
+	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+	PyErr_SetString(PyExc_OverflowError, "unordered_map size not valid in python");
+	SWIG_PYTHON_THREAD_END_BLOCK;
+	return NULL;
+      }    
+      PyObject* itemList = PyList_New(pysize);
+      Map::const_iterator i = self->begin();
+      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
+	PyList_SET_ITEM(itemList, j, swig::from(*i));
+      }
+      return itemList;
+    }
+    
+    // Python 2.2 methods
+    bool __contains__(const key_type& key) {
+      return self->find(key) != self->end();
+    }
+
+    %newobject key_iterator(PyObject **PYTHON_SELF);
+    swig::SwigPyIterator* key_iterator(PyObject **PYTHON_SELF) {
+      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+    }
+
+    %newobject value_iterator(PyObject **PYTHON_SELF);
+    swig::SwigPyIterator* value_iterator(PyObject **PYTHON_SELF) {
+      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+    }
+
+    %pythoncode %{def __iter__(self):
+    return self.key_iterator()%}
+    %pythoncode %{def iterkeys(self):
+    return self.key_iterator()%}
+    %pythoncode %{def itervalues(self):
+    return self.value_iterator()%}
+    %pythoncode %{def iteritems(self):
+    return self.iterator()%}
+  }
+%enddef
+
+%define %swig_unordered_map_methods(Map...)
+  %swig_unordered_map_common(Map)
+  %extend {
+    void __setitem__(const key_type& key, const mapped_type& x) throw (std::out_of_range) {
+      (*self)[key] = x;
+    }
+  }
+%enddef
+
+
+%include <std/std_unordered_map.i>
diff --git a/share/swig/3.0.12/python/std_unordered_multimap.i b/share/swig/3.0.12/python/std_unordered_multimap.i
new file mode 100644
index 0000000..2410aa5
--- /dev/null
+++ b/share/swig/3.0.12/python/std_unordered_multimap.i
@@ -0,0 +1,86 @@
+/*
+  Unordered Multimaps
+*/
+%include <std_unordered_map.i>
+
+%fragment("StdUnorderedMultimapTraits","header",fragment="StdSequenceTraits")
+{
+  namespace swig {
+    template <class SwigPySeq, class K, class T >
+    inline void 
+    assign(const SwigPySeq& swigpyseq, std::unordered_multimap<K,T > *unordered_multimap) {
+      typedef typename std::unordered_multimap<K,T>::value_type value_type;
+      typename SwigPySeq::const_iterator it = swigpyseq.begin();
+      for (;it != swigpyseq.end(); ++it) {
+	unordered_multimap->insert(value_type(it->first, it->second));
+      }
+    }
+
+    template <class K, class T>
+    struct traits_reserve<std::unordered_multimap<K,T> >  {
+      static void reserve(std::unordered_multimap<K,T> &seq, typename std::unordered_multimap<K,T>::size_type n) {
+        seq.reserve(n);
+      }
+    };
+
+    template <class K, class T>
+    struct traits_asptr<std::unordered_multimap<K,T> >  {
+      typedef std::unordered_multimap<K,T> unordered_multimap_type;
+      static int asptr(PyObject *obj, std::unordered_multimap<K,T> **val) {
+	int res = SWIG_ERROR;
+	if (PyDict_Check(obj)) {
+	  SwigVar_PyObject items = PyObject_CallMethod(obj,(char *)"items",NULL);
+	  return traits_asptr_stdseq<std::unordered_multimap<K,T>, std::pair<K, T> >::asptr(items, val);
+	} else {
+	  unordered_multimap_type *p;
+	  swig_type_info *descriptor = swig::type_info<unordered_multimap_type>();
+	  res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
+	  if (SWIG_IsOK(res) && val)  *val = p;
+	}
+	return res;
+      }
+    };
+      
+    template <class K, class T >
+    struct traits_from<std::unordered_multimap<K,T> >  {
+      typedef std::unordered_multimap<K,T> unordered_multimap_type;
+      typedef typename unordered_multimap_type::const_iterator const_iterator;
+      typedef typename unordered_multimap_type::size_type size_type;
+            
+      static PyObject *from(const unordered_multimap_type& unordered_multimap) {
+	swig_type_info *desc = swig::type_info<unordered_multimap_type>();
+	if (desc && desc->clientdata) {
+	  return SWIG_NewPointerObj(new unordered_multimap_type(unordered_multimap), desc, SWIG_POINTER_OWN);
+	} else {
+	  size_type size = unordered_multimap.size();
+	  Py_ssize_t pysize = (size <= (size_type) INT_MAX) ? (Py_ssize_t) size : -1;
+	  if (pysize < 0) {
+	    SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+	    PyErr_SetString(PyExc_OverflowError, "unordered_multimap size not valid in python");
+	    SWIG_PYTHON_THREAD_END_BLOCK;
+	    return NULL;
+	  }
+	  PyObject *obj = PyDict_New();
+	  for (const_iterator i= unordered_multimap.begin(); i!= unordered_multimap.end(); ++i) {
+	    swig::SwigVar_PyObject key = swig::from(i->first);
+	    swig::SwigVar_PyObject val = swig::from(i->second);
+	    PyDict_SetItem(obj, key, val);
+	  }
+	  return obj;
+	}
+      }
+    };
+  }
+}
+
+%define %swig_unordered_multimap_methods(Type...) 
+  %swig_map_common(Type);
+  %extend {
+    void __setitem__(const key_type& key, const mapped_type& x) throw (std::out_of_range) {
+      self->insert(Type::value_type(key,x));
+    }
+  }
+%enddef
+
+%include <std/std_unordered_multimap.i>
+
diff --git a/share/swig/3.0.12/python/std_unordered_multiset.i b/share/swig/3.0.12/python/std_unordered_multiset.i
new file mode 100644
index 0000000..0d9f3d9
--- /dev/null
+++ b/share/swig/3.0.12/python/std_unordered_multiset.i
@@ -0,0 +1,48 @@
+/*
+  Unordered Multisets
+*/
+
+%include <std_unordered_set.i>
+
+%fragment("StdUnorderedMultisetTraits","header",fragment="StdSequenceTraits")
+%{
+  namespace swig {
+    template <class SwigPySeq, class T> 
+    inline void
+    assign(const SwigPySeq& swigpyseq, std::unordered_multiset<T>* seq) {
+      // seq->insert(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented
+      typedef typename SwigPySeq::value_type value_type;
+      typename SwigPySeq::const_iterator it = swigpyseq.begin();
+      for (;it != swigpyseq.end(); ++it) {
+	seq->insert(seq->end(),(value_type)(*it));
+      }
+    }
+
+    template <class T>
+    struct traits_reserve<std::unordered_multiset<T> >  {
+      static void reserve(std::unordered_multiset<T> &seq, typename std::unordered_multiset<T>::size_type n) {
+        seq.reserve(n);
+      }
+    };
+
+    template <class T>
+    struct traits_asptr<std::unordered_multiset<T> >  {
+      static int asptr(PyObject *obj, std::unordered_multiset<T> **m) {
+	return traits_asptr_stdseq<std::unordered_multiset<T> >::asptr(obj, m);
+      }
+    };
+
+    template <class T>
+    struct traits_from<std::unordered_multiset<T> > {
+      static PyObject *from(const std::unordered_multiset<T>& vec) {
+	return traits_from_stdseq<std::unordered_multiset<T> >::from(vec);
+      }
+    };
+  }
+%}
+
+#define %swig_unordered_multiset_methods(Set...) %swig_set_methods(Set)
+
+
+
+%include <std/std_unordered_multiset.i>
diff --git a/share/swig/3.0.12/python/std_unordered_set.i b/share/swig/3.0.12/python/std_unordered_set.i
new file mode 100644
index 0000000..855a28d
--- /dev/null
+++ b/share/swig/3.0.12/python/std_unordered_set.i
@@ -0,0 +1,62 @@
+/*
+  Unordered Sets
+*/
+
+%fragment("StdUnorderedSetTraits","header",fragment="StdSequenceTraits")
+%{
+  namespace swig {
+    template <class SwigPySeq, class T> 
+    inline void 
+    assign(const SwigPySeq& swigpyseq, std::unordered_set<T>* seq) {
+      // seq->insert(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented
+      typedef typename SwigPySeq::value_type value_type;
+      typename SwigPySeq::const_iterator it = swigpyseq.begin();
+      for (;it != swigpyseq.end(); ++it) {
+	seq->insert(seq->end(),(value_type)(*it));
+      }
+    }
+
+    template <class T>
+    struct traits_reserve<std::unordered_set<T> >  {
+      static void reserve(std::unordered_set<T> &seq, typename std::unordered_set<T>::size_type n) {
+        seq.reserve(n);
+      }
+    };
+
+    template <class T>
+    struct traits_asptr<std::unordered_set<T> >  {
+      static int asptr(PyObject *obj, std::unordered_set<T> **s) {
+	return traits_asptr_stdseq<std::unordered_set<T> >::asptr(obj, s);
+      }
+    };
+
+    template <class T>
+    struct traits_from<std::unordered_set<T> > {
+      static PyObject *from(const std::unordered_set<T>& vec) {
+	return traits_from_stdseq<std::unordered_set<T> >::from(vec);
+      }
+    };
+  }
+%}
+
+%define %swig_unordered_set_methods(unordered_set...)
+  %swig_sequence_iterator(unordered_set);
+  %swig_container_methods(unordered_set);
+
+  %extend  {
+     void append(value_type x) {
+       self->insert(x);
+     }
+  
+     bool __contains__(value_type x) {
+       return self->find(x) != self->end();
+     }
+
+     value_type __getitem__(difference_type i) const throw (std::out_of_range) {
+       return *(swig::cgetpos(self, i));
+     }
+
+  };
+%enddef
+
+%include <std/std_unordered_set.i>
diff --git a/share/swig/3.0.12/python/std_vector.i b/share/swig/3.0.12/python/std_vector.i
new file mode 100644
index 0000000..2ac41a5
--- /dev/null
+++ b/share/swig/3.0.12/python/std_vector.i
@@ -0,0 +1,34 @@
+/*
+  Vectors
+*/
+
+%fragment("StdVectorTraits","header",fragment="StdSequenceTraits")
+%{
+  namespace swig {
+    template <class T>
+    struct traits_reserve<std::vector<T> > {
+      static void reserve(std::vector<T> &seq, typename std::vector<T>::size_type n) {
+        seq.reserve(n);
+      }
+    };
+
+    template <class T>
+    struct traits_asptr<std::vector<T> >  {
+      static int asptr(PyObject *obj, std::vector<T> **vec) {
+	return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
+      }
+    };
+    
+    template <class T>
+    struct traits_from<std::vector<T> > {
+      static PyObject *from(const std::vector<T>& vec) {
+	return traits_from_stdseq<std::vector<T> >::from(vec);
+      }
+    };
+  }
+%}
+
+#define %swig_vector_methods(Type...) %swig_sequence_methods(Type)
+#define %swig_vector_methods_val(Type...) %swig_sequence_methods_val(Type);
+
+%include <std/std_vector.i>
diff --git a/share/swig/2.0.11/python/std_vectora.i b/share/swig/3.0.12/python/std_vectora.i
index 3f084bd..3f084bd 100644
--- a/share/swig/2.0.11/python/std_vectora.i
+++ b/share/swig/3.0.12/python/std_vectora.i
diff --git a/share/swig/2.0.11/python/std_wios.i b/share/swig/3.0.12/python/std_wios.i
index 930a57d..930a57d 100644
--- a/share/swig/2.0.11/python/std_wios.i
+++ b/share/swig/3.0.12/python/std_wios.i
diff --git a/share/swig/2.0.11/python/std_wiostream.i b/share/swig/3.0.12/python/std_wiostream.i
index d3a5ee7..d3a5ee7 100644
--- a/share/swig/2.0.11/python/std_wiostream.i
+++ b/share/swig/3.0.12/python/std_wiostream.i
diff --git a/share/swig/2.0.11/python/std_wsstream.i b/share/swig/3.0.12/python/std_wsstream.i
index 8843f56..8843f56 100644
--- a/share/swig/2.0.11/python/std_wsstream.i
+++ b/share/swig/3.0.12/python/std_wsstream.i
diff --git a/share/swig/2.0.11/python/std_wstreambuf.i b/share/swig/3.0.12/python/std_wstreambuf.i
index c0f0920..c0f0920 100644
--- a/share/swig/2.0.11/python/std_wstreambuf.i
+++ b/share/swig/3.0.12/python/std_wstreambuf.i
diff --git a/share/swig/2.0.11/python/std_wstring.i b/share/swig/3.0.12/python/std_wstring.i
index ef86281..ef86281 100644
--- a/share/swig/2.0.11/python/std_wstring.i
+++ b/share/swig/3.0.12/python/std_wstring.i
diff --git a/share/swig/2.0.11/python/stl.i b/share/swig/3.0.12/python/stl.i
index a3566db..a3566db 100644
--- a/share/swig/2.0.11/python/stl.i
+++ b/share/swig/3.0.12/python/stl.i
diff --git a/share/swig/2.0.11/python/typemaps.i b/share/swig/3.0.12/python/typemaps.i
index 5d438ec..5d438ec 100644
--- a/share/swig/2.0.11/python/typemaps.i
+++ b/share/swig/3.0.12/python/typemaps.i
diff --git a/share/swig/2.0.11/python/wchar.i b/share/swig/3.0.12/python/wchar.i
index 308139a..308139a 100644
--- a/share/swig/2.0.11/python/wchar.i
+++ b/share/swig/3.0.12/python/wchar.i
diff --git a/share/swig/3.0.12/r/boost_shared_ptr.i b/share/swig/3.0.12/r/boost_shared_ptr.i
new file mode 100644
index 0000000..8ef8d2e
--- /dev/null
+++ b/share/swig/3.0.12/r/boost_shared_ptr.i
@@ -0,0 +1,309 @@
+%include <shared_ptr.i>
+
+// Language specific macro implementing all the customisations for handling the smart pointer
+%define SWIG_SHARED_PTR_TYPEMAPS(CONST, TYPE...)
+
+// %naturalvar is as documented for member variables
+%naturalvar TYPE;
+%naturalvar SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
+
+// destructor wrapper customisation
+%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) CONST TYPE (void *argp, int res = 0) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (!argp) {
+    %argument_nullref("$type", $symname, $argnum);
+  } else {
+    $1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
+    if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+  }
+}
+%typemap(out) CONST TYPE {
+  %set_output(SWIG_NewPointerObj(new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1)), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) CONST TYPE {
+  void *argp = 0;
+  int newmem = 0;
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  if (!argp) {
+    %variable_nullref("$type", "$name");
+  } else {
+    $1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
+    if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+  }
+}
+%typemap(varout) CONST TYPE {
+  %set_varoutput(SWIG_NewPointerObj(new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1)), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+// plain pointer
+// Note: $disown not implemented as it will lead to a memory leak of the shared_ptr instance
+%typemap(in) CONST TYPE * (void  *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast(tempshared.get(), $1_ltype);
+  } else {
+    smartarg = %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
+  }
+}
+%typemap(out, fragment="SWIG_null_deleter") CONST TYPE * {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), $owner | SWIG_POINTER_OWN));
+}
+
+%typemap(varin) CONST TYPE * {
+  void *argp = 0;
+  int newmem = 0;
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0;
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast(tempshared.get(), $1_ltype);
+  } else {
+    smartarg = %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
+  }
+}
+%typemap(varout, fragment="SWIG_null_deleter") CONST TYPE * {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_0) : 0;
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+// plain reference
+%typemap(in) CONST TYPE & (void  *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (!argp) { %argument_nullref("$type", $symname, $argnum); }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast(tempshared.get(), $1_ltype);
+  } else {
+    $1 = %const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
+  }
+}
+%typemap(out, fragment="SWIG_null_deleter") CONST TYPE & {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner);
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) CONST TYPE & {
+  void *argp = 0;
+  int newmem = 0;
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
+  if (!argp) {
+    %variable_nullref("$type", "$name");
+  }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = *%const_cast(tempshared.get(), $1_ltype);
+  } else {
+    $1 = *%const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
+  }
+}
+%typemap(varout, fragment="SWIG_null_deleter") CONST TYPE & {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(&$1 SWIG_NO_NULL_DELETER_0);
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+// plain pointer by reference
+// Note: $disown not implemented as it will lead to a memory leak of the shared_ptr instance
+%typemap(in) TYPE *CONST& (void  *argp = 0, int res = 0, $*1_ltype temp = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    temp = %const_cast(tempshared.get(), $*1_ltype);
+  } else {
+    temp = %const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $*1_ltype);
+  }
+  $1 = &temp;
+}
+%typemap(out, fragment="SWIG_null_deleter") TYPE *CONST& {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1 SWIG_NO_NULL_DELETER_$owner);
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) TYPE *CONST& %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) TYPE *CONST& %{
+#error "varout typemap not implemented"
+%}
+
+// shared_ptr by value
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > (void *argp, int res = 0) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (argp) $1 = *(%reinterpret_cast(argp, $&ltype));
+  if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $&ltype);
+}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
+  int newmem = 0;
+  void *argp = 0;
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  $1 = argp ? *(%reinterpret_cast(argp, $&ltype)) : SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE >();
+  if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $&ltype);
+}
+%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+// shared_ptr by reference
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & (void *argp, int res = 0, $*1_ltype tempshared) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
+    delete %reinterpret_cast(argp, $ltype);
+    $1 = &tempshared;
+  } else {
+    $1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
+  }
+}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
+#error "varout typemap not implemented"
+%}
+
+// shared_ptr by pointer
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * (void *argp, int res = 0, $*1_ltype tempshared) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
+    delete %reinterpret_cast(argp, $ltype);
+    $1 = &tempshared;
+  } else {
+    $1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
+  }
+}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 && *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+  if ($owner) delete $1;
+}
+
+%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
+#error "varout typemap not implemented"
+%}
+
+// shared_ptr by pointer reference
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& (void *argp, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, $*1_ltype temp = 0) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (argp) tempshared = *%reinterpret_cast(argp, $*ltype);
+  if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $*ltype);
+  temp = &tempshared;
+  $1 = &temp;
+}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 && **$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(**$1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
+#error "varout typemap not implemented"
+%}
+
+// Typecheck typemaps
+// Note: SWIG_ConvertPtr with void ** parameter set to 0 instead of using SWIG_ConvertPtrAndOwn, so that the casting 
+// function is not called thereby avoiding a possible smart pointer copy constructor call when casting up the inheritance chain.
+%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1) 
+                      TYPE CONST,
+                      TYPE CONST &,
+                      TYPE CONST *,
+                      TYPE *CONST&,
+                      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 > *& {
+  int res = SWIG_ConvertPtr($input, 0, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), 0);
+  $1 = SWIG_CheckState(res);
+}
+
+
+// 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"
+%}
+
+
+%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
+%enddef
+
diff --git a/share/swig/2.0.11/tcl/cdata.i b/share/swig/3.0.12/r/cdata.i
index 3679659..3679659 100644
--- a/share/swig/2.0.11/tcl/cdata.i
+++ b/share/swig/3.0.12/r/cdata.i
diff --git a/share/swig/2.0.11/r/exception.i b/share/swig/3.0.12/r/exception.i
index 39cb095..39cb095 100644
--- a/share/swig/2.0.11/r/exception.i
+++ b/share/swig/3.0.12/r/exception.i
diff --git a/share/swig/3.0.12/r/r.swg b/share/swig/3.0.12/r/r.swg
new file mode 100644
index 0000000..cf1cfc8
--- /dev/null
+++ b/share/swig/3.0.12/r/r.swg
@@ -0,0 +1,272 @@
+/* */
+
+
+%insert("header") "swiglabels.swg"
+
+%insert("header") "swigerrors.swg"
+%insert("init") "swiginit.swg"
+%insert("runtime") "swigrun.swg"
+%insert("runtime") "rrun.swg"
+
+%init %{
+SWIGEXPORT void SWIG_init(void) {
+%}
+
+%include <rkw.swg>
+
+#define %Rruntime %insert("s")
+
+#define SWIG_Object SEXP
+#define VOID_Object R_NilValue
+
+#define %append_output(obj) SET_VECTOR_ELT($result, $n, obj)
+
+%define %set_constant(name, obj) %begin_block
+   SEXP _obj = obj;
+   assign(name, _obj);
+%end_block %enddef
+
+%define %raise(obj,type,desc) 
+return R_NilValue;
+%enddef
+
+%insert("sinit") "srun.swg"
+
+%insert("sinitroutine") %{
+SWIG_init();
+SWIG_InitializeModule(0);
+%}
+
+%include <typemaps/swigmacros.swg>
+%typemap(in) (double *x, int len) %{
+   $1 = REAL(x);
+   $2 = Rf_length(x);
+%}
+
+/* XXX
+   Need to worry about inheritance, e.g. if B extends A 
+   and we are looking for an A[], then B elements are okay.
+*/
+%typemap(scheck) SWIGTYPE[ANY]  
+  %{ 
+#      assert(length($input) > $1_dim0)
+      assert(all(sapply($input, class) == "$R_class"));
+  %}
+
+%typemap(out) void "";
+
+%typemap(in) int *, int[ANY],
+	     signed int *, signed int[ANY],
+	     unsigned int *, unsigned int[ANY],
+             short *, short[ANY],
+             signed short *, signed short[ANY],
+             unsigned short *, unsigned short[ANY],
+             long *, long[ANY],
+             signed long *, signed long[ANY],
+             unsigned long *, unsigned long[ANY],
+             long long *, long long[ANY],
+             signed long long *, signed long long[ANY],
+             unsigned long long *, unsigned long long[ANY]
+             
+{
+{ int _rswigi;
+  int _rswiglen = LENGTH($input);
+  $1 = %static_cast(calloc(sizeof($1_basetype), _rswiglen), $1_ltype);
+  for (_rswigi=0; _rswigi< _rswiglen; _rswigi++) {
+     $1[_rswigi] = INTEGER($input)[_rswigi];
+  }
+}
+} 
+
+%typemap(in) float *, float[ANY],
+             double *, double[ANY]
+             
+{
+{  int _rswigi;
+  int _rswiglen = LENGTH($input);
+  $1 = %static_cast(calloc(sizeof($1_basetype), _rswiglen), $1_ltype);
+  for (_rswigi=0; _rswigi<_rswiglen; _rswigi++) {
+     $1[_rswigi] = REAL($input)[_rswigi];
+  }
+}
+}
+
+%typemap(freearg,noblock=1) int *, int[ANY], 
+	     signed int *, signed int[ANY],
+	     unsigned int *, unsigned int[ANY],
+             short *, short[ANY],
+             signed short *, signed short[ANY],
+             unsigned short *, unsigned short[ANY],
+             long *, long[ANY],
+             signed long *, signed long[ANY],
+             unsigned long *, unsigned long[ANY],
+             long long *, long long[ANY],
+             signed long long *, signed long long[ANY],
+             unsigned long long *, unsigned long long[ANY],
+             float *, float[ANY],
+             double *, double[ANY]
+%{             
+  free($1);
+%}
+
+%typemap(freearg, noblock=1) int *OUTPUT,
+signed int *OUTPUT,
+unsigned int *OUTPUT,
+short *OUTPUT,
+signed short *OUTPUT,
+unsigned short *OUTPUT,
+long *OUTPUT,
+signed long *OUTPUT,
+unsigned long *OUTPUT,
+long long *OUTPUT,
+signed long long *OUTPUT,
+unsigned long long *OUTPUT,
+float *OUTPUT,
+double *OUTPUT,
+char *OUTPUT,
+signed char *OUTPUT,
+unsigned char *OUTPUT
+{}
+
+
+
+/* Should we recycle to make the length correct.
+   And warn if length() > the dimension. 
+*/
+%typemap(scheck) SWIGTYPE [ANY] %{
+#  assert(length($input) >= $1_dim0)
+%}
+
+/* Handling vector case to avoid warnings,
+   although we just use the first one. */
+%typemap(scheck) unsigned int %{
+  assert(length($input) == 1 && $input >= 0, "All values must be non-negative");
+%}
+
+
+%typemap(scheck) int, long %{
+  if(length($input) > 1) {
+     warning("using only the first element of $input");
+  };
+%}
+
+%include <typemaps/fragments.swg>
+%include <rfragments.swg>
+%include <ropers.swg>
+%include <typemaps/swigtypemaps.swg>
+%include <rtype.swg>
+
+%typemap(in,noblock=1) enum SWIGTYPE[ANY] {
+   $1 = %reinterpret_cast(INTEGER($input), $1_ltype);
+}
+
+%typemap(in,noblock=1,fragment="SWIG_strdup") char * {
+   $1 = %reinterpret_cast(SWIG_strdup(CHAR(STRING_ELT($input, 0))), $1_ltype);
+}
+
+%typemap(freearg,noblock=1) char * {
+   free($1);
+}
+
+%typemap(in,noblock=1,fragment="SWIG_strdup") char *[ANY]  {
+   $1 = %reinterpret_cast(SWIG_strdup(CHAR(STRING_ELT($input, 0))), $1_ltype);
+}
+
+%typemap(freearg,noblock=1) char *[ANY]  {
+   free($1);
+}
+
+%typemap(in,noblock=1,fragment="SWIG_strdup") char[ANY] {
+    $1 = SWIG_strdup(CHAR(STRING_ELT($input, 0)));
+}
+
+%typemap(freearg,noblock=1) char[ANY] {
+    free($1);
+}
+
+%typemap(in,noblock=1,fragment="SWIG_strdup") char[] {
+    $1 = SWIG_strdup(CHAR(STRING_ELT($input, 0)));
+}
+
+%typemap(freearg,noblock=1) char[] {
+    free($1);
+}
+
+
+%typemap(memberin) char[] %{
+if ($input) strcpy($1, $input);
+else
+strcpy($1, "");
+%}
+
+%typemap(globalin) char[] %{
+if ($input) strcpy($1, $input);
+else
+strcpy($1, "");
+%}
+
+%typemap(out,noblock=1) char * 
+ {  $result = $1 ? Rf_mkString(%reinterpret_cast($1,char *)) : R_NilValue; }
+
+%typemap(in,noblock=1) char {
+$1 = %static_cast(CHAR(STRING_ELT($input, 0))[0],$1_ltype);
+}
+
+%typemap(out) char 
+ { 
+    char tmp[2] = "x";
+    tmp[0] = $1;    
+    $result = Rf_mkString(tmp); 
+ }
+
+
+%typemap(in,noblock=1) int, long
+{
+  $1 = %static_cast(INTEGER($input)[0], $1_ltype);
+}
+
+%typemap(out,noblock=1) int, long
+  "$result = Rf_ScalarInteger($1);";
+
+
+%typemap(in,noblock=1) bool 
+  "$1 = LOGICAL($input)[0] ? true : false;";
+
+
+%typemap(out,noblock=1) bool 
+  "$result = Rf_ScalarLogical($1);";
+
+%typemap(in,noblock=1) 
+             float, 
+             double
+{
+  $1 = %static_cast(REAL($input)[0], $1_ltype); 
+}
+
+/* Why is this here ? */
+/* %typemap(out,noblock=1) unsigned int *
+  "$result = ScalarReal(*($1));"; */
+
+%Rruntime %{
+setMethod('[', "ExternalReference",
+function(x,i,j, ..., drop=TRUE) 
+if (!is.null(x$"__getitem__")) 
+sapply(i, function(n) x$"__getitem__"(i=as.integer(n-1))))
+
+setMethod('[<-' , "ExternalReference",
+function(x,i,j, ..., value) 
+if (!is.null(x$"__setitem__")) {
+sapply(1:length(i), function(n) 
+x$"__setitem__"(i=as.integer(i[n]-1), x=value[n]))
+x
+})
+
+setAs('ExternalReference', 'character',
+function(from) {if (!is.null(from$"__str__")) from$"__str__"()})
+
+suppressMessages(suppressWarnings(setMethod('print', 'ExternalReference',
+function(x) {print(as(x, "character"))})))
+%}
+
+
+
diff --git a/share/swig/2.0.11/r/rcontainer.swg b/share/swig/3.0.12/r/rcontainer.swg
index 54b31b3..54b31b3 100644
--- a/share/swig/2.0.11/r/rcontainer.swg
+++ b/share/swig/3.0.12/r/rcontainer.swg
diff --git a/share/swig/3.0.12/r/rfragments.swg b/share/swig/3.0.12/r/rfragments.swg
new file mode 100644
index 0000000..b89212b
--- /dev/null
+++ b/share/swig/3.0.12/r/rfragments.swg
@@ -0,0 +1,195 @@
+#define SWIG_Error(code, msg) Rf_warning(msg); return Rf_ScalarLogical(NA_LOGICAL)
+
+#define SWIG_fail return Rf_ScalarLogical(NA_LOGICAL)
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(oc, ptr, ty, flags)             SWIG_R_ConvertPtr(oc, ptr, ty, flags)
+#define SWIG_ConvertFunctionPtr(oc, ptr, ty)            SWIG_R_ConvertPtr(oc, ptr, ty, 0)
+#define SWIG_NewPointerObj(ptr, ty, flags)              SWIG_R_NewPointerObj(ptr, ty, flags)
+#define SWIG_NewFunctionPtrObj(ptr, ty)                 SWIG_R_NewPointerObj(ptr, ty, 0)
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_R_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewPackedObj(ptr, sz, ty)                  SWIG_R_NewPackedObj(ptr, sz, ty)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, ty, flags)      SWIG_ConvertPtr(obj, pptr, ty, flags)
+#define SWIG_NewInstanceObj(ptr, ty, flags)             SWIG_NewPointerObj(ptr, ty, flags)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_R_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, ty)                  SWIG_R_NewPackedObj(ptr, sz, ty)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_R_GetModule()
+#define SWIG_SetModule(clientdata, pointer)             SWIG_R_SetModule(pointer)
+
+%fragment(SWIG_From_frag(long),"header") {
+SWIGINTERNINLINE SEXP
+SWIG_From_dec(long)(long value)
+{
+	return Rf_ScalarInteger((int)value);
+}
+}
+
+%fragment(SWIG_AsVal_frag(long),"header") {
+SWIGINTERNINLINE  int
+SWIG_AsVal_dec(long)(SEXP obj, long *val)
+{
+   if (val) *val = Rf_asInteger(obj);
+   return SWIG_OK;
+}
+}
+
+
+%fragment(SWIG_From_frag(long long),"header",
+	  fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERNINLINE SEXP
+SWIG_From_dec(long long)(long long value)
+{
+	return Rf_ScalarInteger((int)value);
+}
+%#endif
+}
+
+%fragment(SWIG_AsVal_frag(long long),"header",
+	  fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERNINLINE  int
+SWIG_AsVal_dec(long long)(SEXP obj, long long *val)
+{
+   if (val) *val = Rf_asInteger(obj);
+   return SWIG_OK;
+}
+%#endif
+}
+
+%fragment(SWIG_From_frag(unsigned long),"header") {
+SWIGINTERNINLINE SEXP
+SWIG_From_dec(unsigned long)(unsigned long value)
+{
+	return Rf_ScalarInteger((int)value);
+}
+}
+
+
+%fragment(SWIG_AsVal_frag(unsigned long),"header") {
+SWIGINTERNINLINE  int
+SWIG_AsVal_dec(unsigned long)(SEXP obj, unsigned long *val)
+{
+   if (val) *val = Rf_asInteger(obj);
+   return SWIG_OK;
+}
+}
+
+
+%fragment(SWIG_From_frag(unsigned long long),"header",
+	  fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERNINLINE SEXP
+SWIG_From_dec(unsigned long long)(unsigned long long value)
+{
+	return Rf_ScalarInteger((int)value);
+}
+%#endif
+}
+
+
+%fragment(SWIG_AsVal_frag(unsigned long long),"header",
+	  fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERNINLINE  int
+SWIG_AsVal_dec(unsigned long long)(SEXP obj, unsigned long long *val)
+{
+   if (val) *val = Rf_asInteger(obj);
+   return SWIG_OK;
+}
+%#endif
+}
+
+%fragment(SWIG_From_frag(double),"header") {
+SWIGINTERNINLINE SEXP
+SWIG_From_dec(double)(double value)
+{
+	return Rf_ScalarReal(value);
+}
+}
+
+
+%fragment(SWIG_AsVal_frag(double),"header") {
+SWIGINTERNINLINE  int
+SWIG_AsVal_dec(double)(SEXP obj, double *val)
+{
+   if (val) *val = Rf_asReal(obj);
+   return SWIG_OK;
+}
+}
+
+%fragment("SWIG_AsCharPtrAndSize", "header") 
+{
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(SEXP obj, char** cptr, size_t* psize, int *alloc)
+{
+  if (cptr && Rf_isString(obj)) {
+    char *cstr = %const_cast(CHAR(STRING_ELT(obj, 0)), char *);
+    int len = strlen(cstr);
+
+    if (alloc) {
+      if (*alloc == SWIG_NEWOBJ) {
+        *cptr = %new_copy_array(cstr, len + 1, char);
+        *alloc = SWIG_NEWOBJ;
+      } else {
+        *cptr = cstr;
+      }
+    } else {
+      *cptr = %reinterpret_cast(malloc(len + 1), char *);
+      *cptr = strcpy(*cptr, cstr);
+    }
+    if (psize) *psize = len + 1;
+    return SWIG_OK;
+  }
+  return SWIG_TypeError;
+}
+}
+
+%fragment("SWIG_strdup","header") 
+{
+SWIGINTERN char *
+SWIG_strdup(const char *str)
+{
+  char *newstr = %reinterpret_cast(malloc(strlen(str) + 1), char *);
+  return strcpy(newstr, str);
+}
+}
+
+//# This is modified from the R header files
+
+%fragment("SWIG_FromCharPtrAndSize","header") 
+{
+SWIGINTERN SEXP
+SWIG_FromCharPtrAndSize(const char* carray, size_t size) 
+{
+  SEXP t, c;
+  if (!carray) return R_NilValue;
+/* See R internals document 1.10.  
+   MkCharLen was introduced in 2.7.0.  Use that instead of hand
+   creating vector.
+
+   Starting in 2.8.0 creating strings via vectors was deprecated in
+   order to allow for use of CHARSXP caches. */
+
+  Rf_protect(t = Rf_allocVector(STRSXP, 1));
+%#if R_VERSION >=  R_Version(2,7,0)
+  c = Rf_mkCharLen(carray, size);
+%#else
+  c = Rf_allocVector(CHARSXP, size);
+  strncpy((char *)CHAR(c), carray, size);
+%#endif
+  SET_STRING_ELT(t, 0, c);
+  Rf_unprotect(1);
+  return t;
+}
+}
diff --git a/share/swig/3.0.12/r/rkw.swg b/share/swig/3.0.12/r/rkw.swg
new file mode 100644
index 0000000..074d7df
--- /dev/null
+++ b/share/swig/3.0.12/r/rkw.swg
@@ -0,0 +1,36 @@
+/*
+  Warnings for R keywords, built-in names and bad names.
+*/
+
+#define RKW(x) %keywordwarn("'" `x` "' is a R keyword, renaming to '_" `x`"'", rename="_%s")  `x`
+#define RSWIGKW(x) %keywordwarn("'" `x` "' is a SWIG R reserved parameter name, renaming to '_" `x`"'", rename="_%s")  `x`
+
+/*
+  Warnings for R reserved words taken from
+  http://cran.r-project.org/doc/manuals/R-lang.html#Reserved-words
+*/
+
+RKW(if);
+RKW(else);
+RKW(repeat);
+RKW(while);
+RKW(function);
+RKW(for);
+RKW(in);
+RKW(next);
+RKW(break);
+RKW(TRUE);
+RKW(FALSE);
+RKW(NULL);
+RKW(Inf);
+RKW(NaN);
+RKW(NA);
+RKW(NA_integer_);
+RKW(NA_real_);
+RKW(NA_complex_);
+RKW(NA_character_);
+
+RSWIGKW(self);
+
+#undef RKW
+#undef RSWIGKW
diff --git a/share/swig/3.0.12/r/ropers.swg b/share/swig/3.0.12/r/ropers.swg
new file mode 100644
index 0000000..acb9979
--- /dev/null
+++ b/share/swig/3.0.12/r/ropers.swg
@@ -0,0 +1,32 @@
+#ifdef __cplusplus
+
+%rename(Equal) operator =;
+%rename(PlusEqual) operator +=;
+%rename(MinusEqual) operator -=;
+%rename(MultiplyEqual) operator *=;
+%rename(DivideEqual) operator /=;
+%rename(PercentEqual) operator %=;
+%rename(Plus) operator +;
+%rename(Minus) operator -;
+%rename(Multiply) operator *;
+%rename(Divide) operator /;
+%rename(Percent) operator %;
+%rename(Not) operator !;
+%rename(IndexIntoConst) operator[](unsigned idx) const;
+%rename(IndexInto) operator[](unsigned idx);
+%rename(Functor) operator ();
+%rename(EqualEqual) operator ==;
+%rename(NotEqual) operator !=;
+%rename(LessThan) operator <;
+%rename(LessThanEqual) operator <=;
+%rename(GreaterThan) operator >;
+%rename(GreaterThanEqual) operator >=;
+%rename(And) operator &&;
+%rename(Or) operator ||;
+%rename(PlusPlusPrefix) operator++();
+%rename(PlusPlusPostfix) operator++(int);
+%rename(MinusMinusPrefix) operator--();
+%rename(MinusMinusPostfix) operator--(int);
+
+
+#endif
diff --git a/share/swig/3.0.12/r/rrun.swg b/share/swig/3.0.12/r/rrun.swg
new file mode 100644
index 0000000..81f6461
--- /dev/null
+++ b/share/swig/3.0.12/r/rrun.swg
@@ -0,0 +1,377 @@
+
+/* Remove global namespace pollution */
+#if !defined(SWIG_NO_R_NO_REMAP)
+# define R_NO_REMAP
+#endif
+#if !defined(SWIG_NO_STRICT_R_HEADERS)
+# define STRICT_R_HEADERS
+#endif
+
+#include <Rdefines.h>
+#include <Rversion.h>
+
+#ifdef __cplusplus
+#include <exception>
+extern "C" {
+#endif
+
+/* for raw pointer */
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_R_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_R_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_R_NewPointerObj(ptr, type, flags)
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#if R_VERSION >= R_Version(2,6,0)
+#define VMAXTYPE void *
+#else
+#define VMAXTYPE char *
+#endif
+
+/*
+  This is mainly a way to avoid having lots of local variables that may 
+  conflict with those in the routine.
+
+   Change name to R_SWIG_Callb....
+*/
+typedef struct RCallbackFunctionData {
+
+  SEXP fun;
+  SEXP userData;
+
+
+  SEXP expr;
+  SEXP retValue;
+  int errorOccurred;
+
+  SEXP el;  /* Temporary pointer used in the construction of the expression to call the R function. */
+
+  struct RCallbackFunctionData *previous;   /* Stack */
+
+} RCallbackFunctionData;
+
+static RCallbackFunctionData  *callbackFunctionDataStack;
+
+
+SWIGRUNTIME SEXP
+R_SWIG_debug_getCallbackFunctionData()
+{
+  int n, i;
+  SEXP ans;
+  RCallbackFunctionData  *p = callbackFunctionDataStack;
+
+  n = 0;
+  while(p) { 
+    n++;
+    p = p->previous;
+  }
+
+  Rf_protect(ans = Rf_allocVector(VECSXP, n));
+  for(p = callbackFunctionDataStack, i = 0; i < n; p = p->previous, i++) 
+      SET_VECTOR_ELT(ans, i, p->fun);
+
+  Rf_unprotect(1);
+
+  return(ans);
+}
+
+
+
+SWIGRUNTIME RCallbackFunctionData *
+R_SWIG_pushCallbackFunctionData(SEXP fun, SEXP userData)
+{
+   RCallbackFunctionData *el;
+   el = (RCallbackFunctionData *) calloc(1, sizeof(RCallbackFunctionData));
+   el->fun = fun;
+   el->userData = userData;
+   el->previous = callbackFunctionDataStack;
+
+   callbackFunctionDataStack = el;
+
+   return(el);
+}
+
+
+SWIGRUNTIME SEXP
+R_SWIG_R_pushCallbackFunctionData(SEXP fun, SEXP userData)
+{
+    R_SWIG_pushCallbackFunctionData(fun, userData);
+    return R_NilValue;
+}
+
+SWIGRUNTIME RCallbackFunctionData *
+R_SWIG_getCallbackFunctionData()
+{
+  if(!callbackFunctionDataStack) {
+    Rf_error("Supposedly impossible error occurred in the SWIG callback mechanism."
+            "  No callback function data set.");
+  }
+  
+  return callbackFunctionDataStack;
+}
+
+SWIGRUNTIME void
+R_SWIG_popCallbackFunctionData(int doFree)
+{
+  RCallbackFunctionData  *el = NULL;
+  if(!callbackFunctionDataStack)
+    return ; /* Error !!! */
+
+  el = callbackFunctionDataStack ;
+  callbackFunctionDataStack = callbackFunctionDataStack->previous;
+
+  if(doFree)
+     free(el);
+}
+
+
+/*
+  Interface to S function
+      is(obj, type)
+  which is to be used to determine if an 
+  external pointer inherits from the right class.
+
+  Ideally, we would like to be able to do this without an explicit call to the is() function.
+  When the S4 class system uses its own SEXP types, then we will hopefully be able to do this
+  in the C code.
+
+  Should we make the expression static and preserve it to avoid the overhead of 
+  allocating each time.
+*/
+SWIGRUNTIME int
+R_SWIG_checkInherits(SEXP obj, SEXP tag, const char *type)
+{
+  SEXP e, val;
+  int check_err = 0;
+
+  Rf_protect(e = Rf_allocVector(LANGSXP, 3));
+  SETCAR(e, Rf_install("extends"));
+
+  SETCAR(CDR(e), Rf_mkString(CHAR(PRINTNAME(tag))));
+  SETCAR(CDR(CDR(e)), Rf_mkString(type));
+
+  val = R_tryEval(e, R_GlobalEnv, &check_err);
+  Rf_unprotect(1);
+  if(check_err) 
+    return(0);
+
+
+  return(LOGICAL(val)[0]);
+}
+
+
+SWIGRUNTIME void *
+R_SWIG_resolveExternalRef(SEXP arg, const char * const type, const char * const argName, Rboolean nullOk)
+{
+  void *ptr;
+  SEXP orig = arg;
+
+  if(TYPEOF(arg) != EXTPTRSXP) 
+    arg = GET_SLOT(arg, Rf_mkString("ref"));
+
+  
+  if(TYPEOF(arg) != EXTPTRSXP) {
+    Rf_error("argument %s must be an external pointer (from an ExternalReference)", argName);
+  }
+
+
+  ptr = R_ExternalPtrAddr(arg);
+
+  if(ptr == NULL && nullOk == (Rboolean) FALSE) {
+    Rf_error("the external pointer (of type %s) for argument %s has value NULL", argName, type);
+  }
+
+  if(type[0] && R_ExternalPtrTag(arg) != Rf_install(type) && strcmp(type, "voidRef")
+      && !R_SWIG_checkInherits(orig,  R_ExternalPtrTag(arg), type)) {
+    Rf_error("the external pointer for argument %s has tag %s, not the expected value %s",
+             argName, CHAR(PRINTNAME(R_ExternalPtrTag(arg))), type);
+  }
+
+
+  return(ptr);
+}
+
+SWIGRUNTIME void
+R_SWIG_ReferenceFinalizer(SEXP el)
+{
+  void *ptr = R_SWIG_resolveExternalRef(el, "", "<finalizer>",  (Rboolean) 1);
+  fprintf(stderr, "In R_SWIG_ReferenceFinalizer for %p\n", ptr);
+  Rf_PrintValue(el);
+
+  if(ptr) {
+     if(TYPEOF(el) != EXTPTRSXP)
+        el = GET_SLOT(el, Rf_mkString("ref"));
+
+     if(TYPEOF(el) == EXTPTRSXP)
+        R_ClearExternalPtr(el);
+
+     free(ptr);
+  }
+
+  return;
+}
+
+typedef enum {R_SWIG_EXTERNAL, R_SWIG_OWNER } R_SWIG_Owner;
+
+SWIGRUNTIME SEXP
+SWIG_MakePtr(void *ptr, const char *typeName, R_SWIG_Owner owner)
+{
+  SEXP external, r_obj;
+
+  Rf_protect(external = R_MakeExternalPtr(ptr, Rf_install(typeName), R_NilValue));
+  Rf_protect(r_obj = NEW_OBJECT(MAKE_CLASS((char *) typeName)));
+
+  if(owner)
+    R_RegisterCFinalizer(external, R_SWIG_ReferenceFinalizer);
+
+  r_obj = SET_SLOT(r_obj, Rf_mkString((char *) "ref"), external);
+  SET_S4_OBJECT(r_obj);
+  Rf_unprotect(2);
+
+  return(r_obj);
+}
+
+
+SWIGRUNTIME SEXP
+R_SWIG_create_SWIG_R_Array(const char *typeName, SEXP ref, int len)
+{
+   SEXP arr;
+
+/*XXX remove the char * cast when we can. MAKE_CLASS should be declared appropriately. */
+   Rf_protect(arr = NEW_OBJECT(MAKE_CLASS((char *) typeName)));
+   Rf_protect(arr = R_do_slot_assign(arr, Rf_mkString("ref"), ref));
+   Rf_protect(arr = R_do_slot_assign(arr, Rf_mkString("dims"), Rf_ScalarInteger(len)));
+
+   Rf_unprotect(3); 			   
+   SET_S4_OBJECT(arr);	
+   return arr;
+}
+
+#define ADD_OUTPUT_ARG(result, pos, value, name)  r_ans = AddOutputArgToReturn(pos, value, name, OutputValues);
+
+SWIGRUNTIME SEXP
+AddOutputArgToReturn(int pos, SEXP value, const char *name, SEXP output)
+{
+  SET_VECTOR_ELT(output, pos, value);
+
+  return(output);
+}
+
+/* Create a new pointer object */
+SWIGRUNTIMEINLINE SEXP
+SWIG_R_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
+  SEXP rptr = R_MakeExternalPtr(ptr, 
+  R_MakeExternalPtr(type, R_NilValue, R_NilValue), R_NilValue); 
+  SET_S4_OBJECT(rptr);
+  return rptr;
+}
+
+
+/* Convert a pointer value */
+SWIGRUNTIMEINLINE int
+SWIG_R_ConvertPtr(SEXP obj, void **ptr, swig_type_info *ty, int flags) {
+  void *vptr;
+  if (!obj) return SWIG_ERROR;
+  if (obj == R_NilValue) {
+    if (ptr) *ptr = NULL;
+    return SWIG_OK;
+  }
+
+  vptr = R_ExternalPtrAddr(obj);
+  if (ty) {
+    swig_type_info *to = (swig_type_info*) 
+      R_ExternalPtrAddr(R_ExternalPtrTag(obj));
+    if (to == ty) {
+      if (ptr) *ptr = vptr;
+    } else {
+      swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
+      int newmemory = 0;
+      if (ptr) *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
+      assert(!newmemory); /* newmemory handling not yet implemented */
+    }
+  } else {
+      if (ptr) *ptr = vptr;
+ }
+  return SWIG_OK;
+}
+
+SWIGRUNTIME swig_module_info *
+SWIG_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
+  static void *type_pointer = (void *)0;
+  return (swig_module_info *) type_pointer;
+}
+
+SWIGRUNTIME void
+SWIG_SetModule(void *v, swig_module_info *swig_module) {
+}
+
+typedef struct {
+  void *pack;
+  swig_type_info *ty;
+  size_t size;
+} RSwigPacked;
+
+/* Create a new packed object */
+
+SWIGRUNTIMEINLINE SEXP RSwigPacked_New(void *ptr, size_t sz,
+		  swig_type_info *ty) {
+  SEXP rptr;
+  RSwigPacked *sobj = 
+  (RSwigPacked*) malloc(sizeof(RSwigPacked));
+  if (sobj) {
+    void *pack = malloc(sz);
+    if (pack) {
+      memcpy(pack, ptr, sz);
+      sobj->pack = pack;
+      sobj->ty   = ty;
+      sobj->size = sz;
+    } else {
+      sobj = 0;
+    }
+  }
+  rptr = R_MakeExternalPtr(sobj, R_NilValue, R_NilValue); 
+  return rptr;
+}
+
+SWIGRUNTIME swig_type_info *
+RSwigPacked_UnpackData(SEXP obj, void *ptr, size_t size)
+{
+    RSwigPacked *sobj = 
+        (RSwigPacked *)R_ExternalPtrAddr(obj);
+    if (sobj->size != size) return 0;
+    memcpy(ptr, sobj->pack, size);
+    return sobj->ty;
+}
+
+SWIGRUNTIMEINLINE SEXP
+SWIG_R_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
+  return ptr ? RSwigPacked_New((void *) ptr, sz, type) : R_NilValue;
+}
+
+/* Convert a packed value value */
+
+SWIGRUNTIME int
+SWIG_R_ConvertPacked(SEXP obj, void *ptr, size_t sz, swig_type_info *ty) {
+  swig_type_info *to = RSwigPacked_UnpackData(obj, ptr, sz);
+  if (!to) return SWIG_ERROR;
+  if (ty) {
+    if (to != ty) {
+      /* check type cast? */
+      swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
+      if (!tc) return SWIG_ERROR;
+    }
+  }
+  return SWIG_OK;
+}  
+
+#ifdef __cplusplus
+#define SWIG_exception_noreturn(code, msg) do { throw std::runtime_error(msg); } while(0)
+#else
+#define SWIG_exception_noreturn(code, msg) do { return result; } while(0)
+#endif
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/share/swig/3.0.12/r/rstdcommon.swg b/share/swig/3.0.12/r/rstdcommon.swg
new file mode 100644
index 0000000..e6c873a
--- /dev/null
+++ b/share/swig/3.0.12/r/rstdcommon.swg
@@ -0,0 +1,211 @@
+%fragment("StdTraits","header",fragment="StdTraitsCommon")
+{
+namespace swig {  
+  /*
+    Traits that provides the from method
+  */
+
+  template <class Type> struct traits_from_ptr {
+    static SWIG_Object from(Type *val, int owner = 0) {
+      return SWIG_NewPointerObj(val, type_info<Type>(), owner);
+    }
+  };
+
+  template <class Type> struct traits_from {
+    static SWIG_Object from(const Type& val) {
+      return traits_from_ptr<Type>::from(new Type(val), 1);
+    }
+  };
+
+  template <class Type> struct traits_from<Type *> {
+    static SWIG_Object from(Type* val) {
+      return traits_from_ptr<Type>::from(val, 0);
+    }
+  };
+
+  template <class Type>
+  inline SWIG_Object from(const Type& val) {
+    return traits_from<Type>::from(val);
+  }
+
+  template <class Type>
+  inline SWIG_Object from_ptr(Type* val, int owner) {
+    return traits_from_ptr<Type>::from(val, owner);
+  }
+
+  /*
+    Traits that provides the asval/as/check method
+  */
+  template <class Type>
+  struct traits_asptr {   
+    static int asptr(SWIG_Object obj, Type **val) {
+      Type *p;
+      swig_type_info *descriptor = type_info<Type>();
+      int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
+      if (SWIG_IsOK(res)) {
+	if (val) *val = p;
+      }
+      return res;
+    }
+  }; 
+
+  template <class Type>
+  inline int asptr(SWIG_Object obj, Type **vptr) {
+    return traits_asptr<Type>::asptr(obj, vptr);
+  }
+
+  template <class Type> 
+  struct traits_asval {
+    static int asval(SWIG_Object obj, Type *val) {
+      if (val) {
+	Type *p = 0;
+	int res = traits_asptr<Type>::asptr(obj, &p);
+	if (!SWIG_IsOK(res)) return res;	
+	if (p) {
+	  typedef typename noconst_traits<Type>::noconst_type noconst_type;
+	  *(const_cast<noconst_type*>(val)) = *p;
+	  if (SWIG_IsNewObj(res)){
+	    %delete(p);
+	    res = SWIG_DelNewMask(res);
+	  }
+	  return res;
+	} else {
+	  return SWIG_ERROR;
+	}
+      } else {
+	return traits_asptr<Type>::asptr(obj, (Type **)(0));
+      }
+    }
+  };
+
+  template <class Type> struct traits_asval<Type*> {
+    static int asval(SWIG_Object obj, Type **val) {
+      if (val) {
+        typedef typename noconst_traits<Type>::noconst_type noconst_type;
+        noconst_type *p = 0;
+        int res = traits_asptr<noconst_type>::asptr(obj,  &p);
+        if (SWIG_IsOK(res)) {
+          *(const_cast<noconst_type**>(val)) = p;
+	}
+	return res;
+      } else {
+	return traits_asptr<Type>::asptr(obj, (Type **)(0));
+      }
+    }
+  };
+  
+  template <class Type>
+  inline int asval(SWIG_Object obj, Type *val) {
+    return traits_asval<Type>::asval(obj, val);
+  }
+
+  template <class Type> 
+  struct traits_as<Type, value_category> {
+    static Type as(SWIG_Object obj, bool throw_error) {
+      Type v;
+      int res = asval(obj, &v);
+      if (!obj || !SWIG_IsOK(res)) {
+	if (throw_error)
+          throw std::invalid_argument("bad type");
+      }
+      return v;
+    }
+  };
+
+  template <class Type> 
+  struct traits_as<Type, pointer_category> {
+    static Type as(SWIG_Object obj, bool throw_error) {
+      Type *v = 0;      
+      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
+      if (SWIG_IsOK(res) && v) {
+	if (SWIG_IsNewObj(res)) {
+	  Type r(*v);
+	  %delete(v);
+	  return r;
+	} else {
+	  return *v;
+	}
+      } else {
+	// Uninitialized return value, no Type() constructor required.
+	static Type *v_def = (Type*) malloc(sizeof(Type));
+	if (throw_error)
+          throw std::invalid_argument("bad type");
+	memset(v_def,0,sizeof(Type));
+	return *v_def;
+      }
+    }
+  };
+
+  template <class Type> 
+  struct traits_as<Type*, pointer_category> {
+    static Type* as(SWIG_Object obj, bool throw_error) {
+      Type *v = 0;      
+      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
+      if (SWIG_IsOK(res)) {
+	return v;
+      } else {
+	if (throw_error)
+          throw std::invalid_argument("bad type");
+	return 0;
+      }
+    }
+  };
+    
+  template <class Type>
+  inline Type as(SWIG_Object obj, bool te = false) {
+    return traits_as<Type, typename traits<Type>::category>::as(obj, te);
+  }
+
+  template <class Type> 
+  struct traits_check<Type, value_category> {
+    static bool check(SWIG_Object obj) {
+      int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
+      return SWIG_IsOK(res) ? true : false;
+    }
+  };
+
+  template <class Type> 
+  struct traits_check<Type, pointer_category> {
+    static bool check(SWIG_Object obj) {
+      int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
+      return SWIG_IsOK(res) ? true : false;
+    }
+  };
+
+  template <class Type>
+  inline bool check(SWIG_Object obj) {
+    return traits_check<Type, typename traits<Type>::category>::check(obj);
+  }
+}
+}
+
+%define %specialize_std_container(Type,Check,As,From)
+%{
+namespace swig {
+  template <>  struct traits_asval<Type > {   
+    typedef Type value_type;
+    static int asval(SWIG_Object obj, value_type *val) {
+      if (Check(obj)) {
+	if (val) *val = As(obj);
+	return SWIG_OK;
+      }
+      return SWIG_ERROR;
+    }
+  };
+  template <>  struct traits_from<Type > {
+    typedef Type value_type;
+    static SWIG_Object from(const value_type& val) {
+      return From(val);
+    }
+  };
+
+  template <> 
+  struct traits_check<Type, value_category> {
+    static int check(SWIG_Object obj) {
+      int res = Check(obj);
+      return obj && res ? res : 0;
+    }
+  };
+}
+%}
+%enddef
diff --git a/share/swig/3.0.12/r/rtype.swg b/share/swig/3.0.12/r/rtype.swg
new file mode 100644
index 0000000..22639f2
--- /dev/null
+++ b/share/swig/3.0.12/r/rtype.swg
@@ -0,0 +1,317 @@
+
+/* These map the primitive C types to the appropriate R type
+   for use in class representations. 
+ */
+
+%typemap("rtype") int, int *, int &      "integer";
+%typemap("rtype") long, long *, long &      "integer";
+%typemap("rtype") float, float*, float & "numeric";
+%typemap("rtype") double, double*, double & "numeric";
+%typemap("rtype") char *, char ** "character";
+%typemap("rtype") char            "character";
+%typemap("rtype") string, string *, string & "character";
+%typemap("rtype") std::string, std::string *, std::string & "character";
+%typemap("rtype") bool, bool *    "logical";
+%typemap("rtype") enum SWIGTYPE   "character";
+%typemap("rtype") enum SWIGTYPE *   "character";
+%typemap("rtype") enum SWIGTYPE *const   "character";
+%typemap("rtype") enum SWIGTYPE &  "character";
+%typemap("rtype") enum SWIGTYPE &&  "character";
+%typemap("rtype") SWIGTYPE * "$R_class";
+%typemap("rtype") SWIGTYPE *const "$R_class";
+%typemap("rtype") SWIGTYPE & "$R_class";
+%typemap("rtype") SWIGTYPE && "$R_class";
+%typemap("rtype") SWIGTYPE "$&R_class";
+
+%typemap("rtypecheck") int, int &, long, long &
+  %{ (is.integer($arg) || is.numeric($arg)) && length($arg) == 1 %}
+%typemap("rtypecheck") int *, long *
+  %{ is.integer($arg) || is.numeric($arg) %}
+
+
+%typemap("rtypecheck") float, double
+  %{ is.numeric($arg) && length($arg) == 1 %}
+%typemap("rtypecheck") float *, double *
+  %{ is.numeric($arg) %}
+
+%typemap("rtypecheck") bool, bool &
+  %{ is.logical($arg) && length($arg) == 1 %}
+%typemap("rtypecheck") bool *
+  %{ is.logical($arg) %}
+
+/*
+  Set up type checks to insure overloading precedence.
+  We would like non pointer items to shadow pointer items, so that 
+  they get called if length = 1
+*/
+
+%typecheck(SWIG_TYPECHECK_BOOL) bool {}
+%typecheck(SWIG_TYPECHECK_UINT32) unsigned int {}
+%typecheck(SWIG_TYPECHECK_INTEGER) int {}
+%typecheck(SWIG_TYPECHECK_FLOAT) float {}
+%typecheck(SWIG_TYPECHECK_DOUBLE) double {}
+
+%typecheck(SWIG_TYPECHECK_BOOL_PTR) bool * {}
+%typecheck(SWIG_TYPECHECK_INT32_PTR) int * {}
+%typecheck(SWIG_TYPECHECK_FLOAT_PTR) float * {}
+%typecheck(SWIG_TYPECHECK_DOUBLE_PTR) double * {}
+%typecheck(SWIG_TYPECHECK_CHAR_PTR) char * {}
+
+%typecheck(SWIG_TYPECHECK_INT32_ARRAY) int[ANY] {}
+%typecheck(SWIG_TYPECHECK_FLOAT_ARRAY) float[ANY] {}
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY) double [ANY] {}
+
+/* Have to be careful that as(x, "numeric") is different from as.numeric(x).  
+   The latter makes a REALSXP, whereas the former leaves an INTSXP as an
+   INTSXP.
+*/
+
+/* Force coercion of integer, since by default R sets all constants to
+   numeric, which means that you can't directly call a function with an 
+   integer using an R numercal literal */
+
+%typemap(scoercein) int, int *, int &
+  %{  $input = as.integer($input);     %}
+%typemap(scoercein) long, long *, long &
+  %{  $input = as.integer($input);     %}
+%typemap(scoercein) float, float*, float &,
+  double, double *, double &
+  %{ %}
+%typemap(scoercein) char, char *, char &
+  %{  $input = as($input, "character");     %}
+%typemap(scoercein) string, string *, string &
+  %{  $input = as($input, "character");     %}
+%typemap(scoercein) std::string, std::string *, std::string &
+  %{  $input = as($input, "character");     %}
+%typemap(scoercein) enum SWIGTYPE 
+  %{  $input = enumToInteger($input, "$R_class"); %}
+%typemap(scoercein) enum SWIGTYPE &
+  %{  $input = enumToInteger($input, "$R_class"); %}
+%typemap(scoercein) enum SWIGTYPE &&
+  %{  $input = enumToInteger($input, "$R_class"); %}
+%typemap(scoercein) enum SWIGTYPE *
+  %{  $input = enumToInteger($input, "$R_class"); %}
+%typemap(scoercein) enum SWIGTYPE *const
+  %{  $input = enumToInteger($input, "$R_class"); %}
+
+%typemap(scoercein) SWIGTYPE, SWIGTYPE *, SWIGTYPE *const, SWIGTYPE &, SWIGTYPE &&
+ %{ if (inherits($input, "ExternalReference")) $input = slot($input,"ref") %}
+
+/*
+%typemap(scoercein) SWIGTYPE *, SWIGTYPE *const
+  %{ $input = coerceIfNotSubclass($input, "$R_class") %}
+
+%typemap(scoercein) SWIGTYPE & 
+  %{ $input = coerceIfNotSubclass($input, "$R_class") %}
+
+%typemap(scoercein) SWIGTYPE && 
+  %{ $input = coerceIfNotSubclass($input, "$R_class") %}
+
+%typemap(scoercein) SWIGTYPE  
+  %{ $input = coerceIfNotSubclass($input, "$&R_class") %}
+*/
+
+%typemap(scoercein) SWIGTYPE[ANY]  
+ %{
+    if(is.list($input))
+      assert(all(sapply($input, class) == "$R_class"));
+ %}
+
+
+/* **************************************************************** */
+
+%typemap(scoercein) bool, bool *, bool & 
+		    "$input = as.logical($input);";
+%typemap(scoercein) int, 
+                    int *, 
+		    int &,
+		    long,
+		    long *,
+		    long &
+  "$input = as.integer($input);";
+
+%typemap(scoercein) char *, string, std::string,
+string &, std::string &
+%{  $input = as($input, "character"); %}
+
+%typemap(scoerceout) enum SWIGTYPE 
+  %{  $result = enumFromInteger($result, "$R_class"); %}
+
+%typemap(scoerceout) enum SWIGTYPE &
+  %{  $result = enumFromInteger($result, "$R_class"); %}
+
+%typemap(scoerceout) enum SWIGTYPE &&
+  %{  $result = enumFromInteger($result, "$R_class"); %}
+
+%typemap(scoerceout) enum SWIGTYPE *
+  %{  $result = enumToInteger($result, "$R_class"); %}
+
+%typemap(scoerceout) enum SWIGTYPE *const
+  %{  $result = enumToInteger($result, "$R_class"); %}
+
+%typemap(scoerceout) SEXP %{ %}
+
+%typemap(scoerceout) SWIGTYPE
+  %{ $result <- new("$&R_class", ref=$result); %}
+ 
+%typemap(scoerceout) SWIGTYPE &
+  %{ $result <- new("$R_class", ref=$result) ; %}
+ 
+%typemap(scoerceout) SWIGTYPE &&
+  %{ $result <- new("$R_class", ref=$result) ; %}
+ 
+%typemap(scoerceout) SWIGTYPE *
+  %{ $result <- new("$R_class", ref=$result) ; %}
+ 
+%typemap(scoerceout) SWIGTYPE *const
+  %{ $result <- new("$R_class", ref=$result) ; %}
+
+
+/* Override the SWIGTYPE * above. */
+%typemap(scoerceout) char,
+		     char *,
+		     char &,
+                     float,
+		     double,
+		     float*,
+		     double*,
+		     float &,
+		     double &,
+                     int,
+		     int &,
+		     long,
+		     long &,
+                     bool,
+		     bool &,
+		     string,
+		     std::string,
+		     string &,
+		     std::string &, 
+		     void,
+		     signed int,
+		     signed int &,		     
+		     unsigned int,
+		     unsigned int &,		     
+		     short,
+		     short &,		     
+		     unsigned short,
+		     unsigned short &,		     
+		     long long,
+		     signed long long,
+		     signed long long &,		     
+		     unsigned long long,
+		     unsigned long long &,		     
+		     signed long,
+		     signed long &,		     
+		     unsigned long,
+		     unsigned long &,
+		     signed char,
+		     signed char &,
+		     unsigned char,
+		     unsigned char &
+ %{    %}
+
+%apply int {size_t,
+std::size_t,
+ptrdiff_t,
+std::ptrdiff_t,
+signed int,
+unsigned int,
+short,
+unsigned short,
+signed char,
+unsigned char}
+
+%apply int* {size_t[],
+std::size_t[],
+ptrdiff_t[],
+std::ptrdiff_t[],
+signed int[],
+unsigned int[],
+short[],
+unsigned short[],
+signed char[],
+unsigned char[]}
+
+%apply int* {size_t[ANY],
+std::size_t[ANY],
+ptrdiff_t[ANY],
+std::ptrdiff_t[ANY],
+signed int[ANY],
+unsigned int[ANY],
+short[ANY],
+unsigned short[ANY],
+signed char[ANY],
+unsigned char[ANY]}
+
+%apply int* {size_t*,
+std::size_t*,
+ptrdiff_t*,
+std::ptrdiff_t*,
+signed int*,
+unsigned int*,
+short*,
+unsigned short*,
+signed char*,
+unsigned char*}
+
+%apply long {
+       long long,
+       signed long long,
+       unsigned long long,
+       signed long,
+       unsigned long}
+
+%apply long* {
+       long long*,
+       signed long long*,
+       unsigned long long*,
+       signed long*,
+       unsigned long*,
+       long long[],
+       signed long long[],
+       unsigned long long[],
+       signed long[],
+       unsigned long[],
+       long long[ANY],
+       signed long long[ANY],
+       unsigned long long[ANY],
+       signed long[ANY],
+       unsigned long[ANY]}
+
+%apply float* {
+       float[],
+       float[ANY]
+}
+%apply double * {
+       double[],
+       double[ANY]
+}
+
+%apply bool* {
+       bool[],
+       bool[ANY]
+}
+
+#if 0
+ Just examining the values for a SWIGTYPE.
+
+%typemap(scoerceout) SWIGTYPE  %{
+
+  name = $1_name
+  type = $1_type
+  ltype = $1_ltype
+
+  mangle = $1_mangle
+  descriptor = $1_descriptor
+
+  pointer type = $*1_type
+  pointer ltype = $*1_ltype
+
+  pointer descriptor = $*1_descriptor
+  basetype = $*_basetype
+
+%}
+#endif
+
+
diff --git a/share/swig/3.0.12/r/srun.swg b/share/swig/3.0.12/r/srun.swg
new file mode 100644
index 0000000..2045ab9
--- /dev/null
+++ b/share/swig/3.0.12/r/srun.swg
@@ -0,0 +1,150 @@
+#                         srun.swg                            #
+#
+# This is the basic code that is needed at run time within R to
+# provide and define the relevant classes.  It is included
+# automatically in the generated code by copying the contents of
+# srun.swg into the newly created binding code.
+
+
+# This could be provided as a separate run-time library but this
+# approach allows the code to to be included directly into the
+# generated bindings and so removes the need to have and install an
+# additional library.  We may however end up with multiple copies of
+# this and some confusion at run-time as to which class to use. This
+# is an issue when we use NAMESPACES as we may need to export certain
+# classes.
+
+######################################################################
+
+if(length(getClassDef("RSWIGStruct")) == 0) 
+  setClass("RSWIGStruct", representation("VIRTUAL"))
+
+
+
+if(length(getClassDef("ExternalReference")) == 0) 
+# Should be virtual but this means it loses its slots currently
+#representation("VIRTUAL")
+  setClass("ExternalReference", representation( ref = "externalptr"))
+
+
+
+if(length(getClassDef("NativeRoutinePointer")) == 0) 
+  setClass("NativeRoutinePointer", 
+              representation(parameterTypes = "character",
+                             returnType = "character",
+                             "VIRTUAL"), 
+              contains = "ExternalReference")
+
+if(length(getClassDef("CRoutinePointer")) == 0) 
+  setClass("CRoutinePointer", contains = "NativeRoutinePointer")
+
+
+if(length(getClassDef("EnumerationValue")) == 0) 
+  setClass("EnumerationValue", contains = "integer")
+
+
+if(!isGeneric("copyToR")) 
+ setGeneric("copyToR",
+            function(value, obj = new(gsub("Ref$", "", class(value)))) 
+               standardGeneric("copyToR"
+           ))
+
+setGeneric("delete", function(obj) standardGeneric("delete"))
+
+
+SWIG_createNewRef = 
+function(className, ..., append = TRUE)
+{
+  f = get(paste("new", className, sep = "_"), mode = "function")
+
+  f(...)
+}
+
+if(!isGeneric("copyToC")) 
+ setGeneric("copyToC", 
+             function(value, obj = SWIG_createNewRef(class(value)))
+              standardGeneric("copyToC"
+            ))
+
+
+# 
+defineEnumeration =
+function(name, .values, where = topenv(parent.frame()), suffix = "Value")
+{
+   # Mirror the class definitions via the E analogous to .__C__
+  defName = paste(".__E__", name, sep = "")
+  assign(defName,  .values,  envir = where)
+
+  if(nchar(suffix))
+    name = paste(name, suffix, sep = "")
+
+  setClass(name, contains = "EnumerationValue", where = where)
+}
+
+enumToInteger <- function(name,type)
+{
+   if (is.character(name)) {
+   ans <- as.integer(get(paste(".__E__", type, sep = ""))[name])
+   if (is.na(ans)) {warning("enum not found ", name, " ", type)}
+   ans
+   } 
+}
+
+enumFromInteger =
+function(i,type)
+{
+  itemlist <- get(paste(".__E__", type, sep=""))
+  names(itemlist)[match(i, itemlist)]
+}
+
+coerceIfNotSubclass =
+function(obj, type) 
+{
+    if(!is(obj, type)) {as(obj, type)} else obj
+}
+
+
+setClass("SWIGArray", representation(dims = "integer"), contains = "ExternalReference")
+
+setMethod("length", "SWIGArray", function(x) x@dims[1])
+
+
+defineEnumeration("SCopyReferences",
+                   .values = c( "FALSE" = 0, "TRUE" = 1, "DEEP" = 2))
+
+assert = 
+function(condition, message = "")
+{
+  if(!condition)
+    stop(message)
+
+  TRUE
+}
+
+
+if(FALSE) {
+print.SWIGFunction =
+function(x, ...)
+ {
+ }
+}
+
+
+#######################################################################
+
+R_SWIG_getCallbackFunctionStack =
+function()
+{
+    # No PACKAGE argument as we don't know what the DLL is.
+  .Call("R_SWIG_debug_getCallbackFunctionData")
+}
+
+R_SWIG_addCallbackFunctionStack =
+function(fun, userData = NULL)
+{
+    # No PACKAGE argument as we don't know what the DLL is.
+  .Call("R_SWIG_R_pushCallbackFunctionData", fun, userData)
+}
+
+
+#######################################################################
diff --git a/share/swig/2.0.11/r/std_alloc.i b/share/swig/3.0.12/r/std_alloc.i
index 87fa8d4..87fa8d4 100644
--- a/share/swig/2.0.11/r/std_alloc.i
+++ b/share/swig/3.0.12/r/std_alloc.i
diff --git a/share/swig/3.0.12/r/std_common.i b/share/swig/3.0.12/r/std_common.i
new file mode 100644
index 0000000..cda2623
--- /dev/null
+++ b/share/swig/3.0.12/r/std_common.i
@@ -0,0 +1,73 @@
+%include <rstdcommon.swg>
+
+
+/*
+  Generate the traits for a 'primitive' type, such as 'double',
+  for which the SWIG_AsVal and SWIG_From methods are already defined.
+*/
+
+%define %traits_ptypen(Type...)
+  %fragment(SWIG_Traits_frag(Type),"header",
+	    fragment=SWIG_AsVal_frag(Type),
+	    fragment=SWIG_From_frag(Type),
+	    fragment="StdTraits") {
+namespace swig {
+  template <> struct traits< Type > {
+    typedef value_category category;
+    static const char* type_name() { return  #Type; }
+  };
+  template <>  struct traits_asval< Type > {
+    typedef Type value_type;
+    static int asval(SEXP obj, value_type *val) {
+      return SWIG_AsVal(Type)(obj, val);
+    }
+  };
+  template <>  struct traits_from< Type > {
+    typedef Type value_type;
+    static SEXP from(const value_type& val) {
+      return SWIG_From(Type)(val);
+    }
+  };
+}
+}
+%enddef
+
+/* Traits for enums. This is bit of a sneaky trick needed because a generic template specialization of enums
+   is not possible (unless using template meta-programming which SWIG doesn't support because of the explicit
+   instantiations required using %template). The STL containers define the 'front' method and the typemap
+   below is used whenever the front method is wrapped returning an enum. This typemap simply picks up the
+   standard enum typemap, but additionally drags in a fragment containing the traits_asval and traits_from
+   required in the generated code for enums. */
+
+%define %traits_enum(Type...)
+  %fragment("SWIG_Traits_enum_"{Type},"header",
+	    fragment=SWIG_AsVal_frag(int),
+	    fragment=SWIG_From_frag(int),
+	    fragment="StdTraits") {
+namespace swig {
+  template <>  struct traits_asval< Type > {
+    typedef Type value_type;
+    static int asval(SEXP obj, value_type *val) {
+      return SWIG_AsVal(int)(obj, (int *)val);
+    }
+  };
+  template <>  struct traits_from< Type > {
+    typedef Type value_type;
+    static SEXP from(const value_type& val) {
+      return SWIG_From(int)((int)val);
+    }
+  };
+}
+}
+%typemap(out, fragment="SWIG_Traits_enum_"{Type}) const enum SWIGTYPE& front %{$typemap(out, const enum SWIGTYPE&)%}
+%enddef
+
+
+%include <std/std_common.i>
+
+//
+// Generates the traits for all the known primitive
+// C++ types (int, double, ...)
+//
+%apply_cpptypes(%traits_ptypen);
+
diff --git a/share/swig/2.0.11/r/std_container.i b/share/swig/3.0.12/r/std_container.i
index 076c1c6..076c1c6 100644
--- a/share/swig/2.0.11/r/std_container.i
+++ b/share/swig/3.0.12/r/std_container.i
diff --git a/share/swig/2.0.11/r/std_deque.i b/share/swig/3.0.12/r/std_deque.i
index 0c757ab..0c757ab 100644
--- a/share/swig/2.0.11/r/std_deque.i
+++ b/share/swig/3.0.12/r/std_deque.i
diff --git a/share/swig/2.0.11/tcl/std_except.i b/share/swig/3.0.12/r/std_except.i
index af98428..af98428 100644
--- a/share/swig/2.0.11/tcl/std_except.i
+++ b/share/swig/3.0.12/r/std_except.i
diff --git a/share/swig/2.0.11/r/std_list.i b/share/swig/3.0.12/r/std_list.i
index d67ec02..d67ec02 100644
--- a/share/swig/2.0.11/r/std_list.i
+++ b/share/swig/3.0.12/r/std_list.i
diff --git a/share/swig/2.0.11/r/std_map.i b/share/swig/3.0.12/r/std_map.i
index 5605751..5605751 100644
--- a/share/swig/2.0.11/r/std_map.i
+++ b/share/swig/3.0.12/r/std_map.i
diff --git a/share/swig/2.0.11/r/std_pair.i b/share/swig/3.0.12/r/std_pair.i
index e980344..e980344 100644
--- a/share/swig/2.0.11/r/std_pair.i
+++ b/share/swig/3.0.12/r/std_pair.i
diff --git a/share/swig/3.0.12/r/std_string.i b/share/swig/3.0.12/r/std_string.i
new file mode 100644
index 0000000..dc1378a
--- /dev/null
+++ b/share/swig/3.0.12/r/std_string.i
@@ -0,0 +1 @@
+%include <typemaps/std_string.swg>
diff --git a/share/swig/3.0.12/r/std_vector.i b/share/swig/3.0.12/r/std_vector.i
new file mode 100644
index 0000000..4ec51dc
--- /dev/null
+++ b/share/swig/3.0.12/r/std_vector.i
@@ -0,0 +1,1073 @@
+// R specific swig components
+/*
+  Vectors
+*/
+
+%fragment("StdVectorTraits","header",fragment="StdSequenceTraits")
+%{
+  namespace swig {
+    // vectors of doubles
+    template <>
+      struct traits_from_ptr<std::vector<double> > {
+      static SEXP from (std::vector<double > *val, int owner = 0) {
+        SEXP result;
+        PROTECT(result = Rf_allocVector(REALSXP, val->size()));
+        for (unsigned pos = 0; pos < val->size(); pos++)
+          {
+            NUMERIC_POINTER(result)[pos] = ((*val)[pos]);
+          }
+        UNPROTECT(1);
+        return(result);
+      }
+    };
+    // vectors of floats
+    template <>
+      struct traits_from_ptr<std::vector<float> > {
+      static SEXP from (std::vector<float > *val, int owner = 0) {
+        SEXP result;
+        PROTECT(result = Rf_allocVector(REALSXP, val->size()));
+        for (unsigned pos = 0; pos < val->size(); pos++)
+          {
+            NUMERIC_POINTER(result)[pos] = ((*val)[pos]);
+          }
+        UNPROTECT(1);
+        return(result);
+      }
+    };
+    // vectors of unsigned 8bit int
+    template <>
+      struct traits_from_ptr<std::vector<unsigned char> > {
+      static SEXP from (std::vector<unsigned char > *val, int owner = 0) {
+        SEXP result;
+        PROTECT(result = Rf_allocVector(INTSXP, val->size()));
+        for (unsigned pos = 0; pos < val->size(); pos++)
+          {
+            INTEGER_POINTER(result)[pos] = ((*val)[pos]);
+          }
+        UNPROTECT(1);
+        return(result);
+      }
+    };
+    // vectors of 8bit int
+    template <>
+      struct traits_from_ptr<std::vector<signed char> > {
+      static SEXP from (std::vector<signed char > *val, int owner = 0) {
+        SEXP result;
+        PROTECT(result = Rf_allocVector(INTSXP, val->size()));
+        for (unsigned pos = 0; pos < val->size(); pos++)
+          {
+            INTEGER_POINTER(result)[pos] = ((*val)[pos]);
+          }
+        UNPROTECT(1);
+        return(result);
+      }
+    };
+
+    // vectors of unsigned 16bit int
+    template <>
+      struct traits_from_ptr<std::vector<unsigned short int> > {
+      static SEXP from (std::vector<unsigned short int > *val, int owner = 0) {
+        SEXP result;
+        PROTECT(result = Rf_allocVector(INTSXP, val->size()));
+        for (unsigned pos = 0; pos < val->size(); pos++)
+          {
+            INTEGER_POINTER(result)[pos] = ((*val)[pos]);
+          }
+        UNPROTECT(1);
+        return(result);
+      }
+    };
+    // vectors of 16bit int
+    template <>
+      struct traits_from_ptr<std::vector<short int> > {
+      static SEXP from (std::vector<short int > *val, int owner = 0) {
+        SEXP result;
+        PROTECT(result = Rf_allocVector(INTSXP, val->size()));
+        for (unsigned pos = 0; pos < val->size(); pos++)
+          {
+            INTEGER_POINTER(result)[pos] = ((*val)[pos]);
+          }
+        UNPROTECT(1);
+        return(result);
+      }
+    };
+
+   // vectors of 32 bit unsigned int
+    template <>
+      struct traits_from_ptr<std::vector<unsigned int> > {
+      static SEXP from (std::vector<unsigned int> *val, int owner = 0) {
+        SEXP result;
+        PROTECT(result = Rf_allocVector(INTSXP, val->size()));
+        for (unsigned pos = 0; pos < val->size(); pos++)
+          {
+            INTEGER_POINTER(result)[pos] = ((*val)[pos]);
+          }
+        UNPROTECT(1);
+        return(result);
+      }
+    };
+
+    // vectors of 32bit int
+    template <>
+      struct traits_from_ptr<std::vector<int> > {
+      static SEXP from (std::vector<int > *val, int owner = 0) {
+        SEXP result;
+        PROTECT(result = Rf_allocVector(INTSXP, val->size()));
+        for (unsigned pos = 0; pos < val->size(); pos++)
+          {
+            INTEGER_POINTER(result)[pos] = ((*val)[pos]);
+          }
+        UNPROTECT(1);
+        return(result);
+      }
+    };
+
+   // vectors of 64 bit unsigned int
+#if defined(SWIGWORDSIZE64)
+    template <>
+      struct traits_from_ptr<std::vector<unsigned long int> > {
+      static SEXP from (std::vector<unsigned long int> *val, int owner = 0) {
+        SEXP result;
+        PROTECT(result = Rf_allocVector(INTSXP, val->size()));
+        for (unsigned pos = 0; pos < val->size(); pos++)
+          {
+            INTEGER_POINTER(result)[pos] = ((*val)[pos]);
+          }
+        UNPROTECT(1);
+        return(result);
+      }
+    };
+     // vectors of 64 bit int
+    template <>
+      struct traits_from_ptr<std::vector<long int> > {
+      static SEXP from (std::vector<long int> *val, int owner = 0) {
+        SEXP result;
+        PROTECT(result = Rf_allocVector(INTSXP, val->size()));
+        for (unsigned pos = 0; pos < val->size(); pos++)
+          {
+            INTEGER_POINTER(result)[pos] = ((*val)[pos]);
+          }
+        UNPROTECT(1);
+        return(result);
+      }
+    };
+#else
+    template <>
+      struct traits_from_ptr<std::vector<unsigned long long int> > {
+      static SEXP from (std::vector<unsigned long long int> *val, int owner = 0) {
+        SEXP result;
+        PROTECT(result = Rf_allocVector(INTSXP, val->size()));
+        for (unsigned pos = 0; pos < val->size(); pos++)
+          {
+            INTEGER_POINTER(result)[pos] = ((*val)[pos]);
+          }
+        UNPROTECT(1);
+        return(result);
+      }
+    };
+     // vectors of 64 bit int
+    template <>
+      struct traits_from_ptr<std::vector<long long int> > {
+      static SEXP from (std::vector<long long int> *val, int owner = 0) {
+        SEXP result;
+        PROTECT(result = Rf_allocVector(INTSXP, val->size()));
+        for (unsigned pos = 0; pos < val->size(); pos++)
+          {
+            INTEGER_POINTER(result)[pos] = ((*val)[pos]);
+          }
+        UNPROTECT(1);
+        return(result);
+      }
+    };
+#endif
+    // vectors of bool
+    template <>
+      struct traits_from_ptr<std::vector<bool> > {
+      static SEXP from (std::vector<bool> *val, int owner = 0) {
+        SEXP result;
+        PROTECT(result = Rf_allocVector(LGLSXP, val->size()));
+        for (unsigned pos = 0; pos < val->size(); pos++)
+          {
+            LOGICAL_POINTER(result)[pos] = ((*val)[pos]);
+          }
+        UNPROTECT(1);
+        return(result);
+      }
+    };
+    
+    // vectors of strings
+    template <>
+      struct traits_from_ptr<std::vector<std::basic_string<char> > > {
+      static SEXP from (std::vector<std::basic_string<char> > *val, int owner = 0) {
+        SEXP result;
+         PROTECT(result = Rf_allocVector(STRSXP, val->size()));
+         for (unsigned pos = 0; pos < val->size(); pos++)
+           {
+             CHARACTER_POINTER(result)[pos] = Rf_mkChar(((*val)[pos]).c_str());
+           }
+        UNPROTECT(1);
+        return(result);
+      }
+    };
+
+    // catch all that does everything with vectors
+    template <typename T>
+      struct traits_from_ptr< std::vector< T > > {
+      static SEXP from (std::vector< T > *val, int owner = 0) {
+        return SWIG_R_NewPointerObj(val, type_info< std::vector< T >  >(), owner);
+      }
+    };
+    /////////////////////////////////////////////////
+    template <>
+  struct traits_asptr < std::vector<double> > {
+    static int asptr(SEXP obj, std::vector<double> **val) {
+      std::vector<double> *p;
+      // not sure how to check the size of the SEXP obj is correct
+      unsigned int sexpsz = Rf_length(obj);
+      p = new std::vector<double>(sexpsz);
+      double *S = NUMERIC_POINTER(obj);
+      for (unsigned pos = 0; pos < p->size(); pos++)
+        {
+          (*p)[pos] = static_cast<double>(S[pos]);
+        }
+      int res = SWIG_OK;
+      if (SWIG_IsOK(res)) {
+        if (val) *val = p;
+      }
+      return res;
+    }
+  };
+
+    template <>
+  struct traits_asptr < std::vector<float> > {
+    static int asptr(SEXP obj, std::vector<float> **val) {
+      std::vector<float> *p;
+      // not sure how to check the size of the SEXP obj is correct
+      unsigned int sexpsz = Rf_length(obj);
+      p = new std::vector<float>(sexpsz);
+      double *S = NUMERIC_POINTER(obj);
+      for (unsigned pos = 0; pos < p->size(); pos++)
+        {
+          (*p)[pos] = static_cast<double>(S[pos]);
+        }
+      int res = SWIG_OK;
+      if (SWIG_IsOK(res)) {
+        if (val) *val = p;
+      }
+      return res;
+    }
+  };
+
+    // 8 bit integer types
+    template <>
+  struct traits_asptr < std::vector<unsigned char> > {
+    static int asptr(SEXP obj, std::vector<unsigned char> **val) {
+      std::vector<unsigned char> *p;
+      unsigned int sexpsz = Rf_length(obj);
+      p = new std::vector<unsigned char>(sexpsz);
+      SEXP coerced;
+      PROTECT(coerced = Rf_coerceVector(obj, INTSXP));
+      int *S = INTEGER_POINTER(coerced);
+      for (unsigned pos = 0; pos < p->size(); pos++)
+        {
+          (*p)[pos] = static_cast<unsigned char>(S[pos]);
+        }
+      int res = SWIG_OK;
+      if (SWIG_IsOK(res)) {
+        if (val) *val = p;
+      }
+      UNPROTECT(1);
+      return res;
+    }
+  };
+
+    template <>
+  struct traits_asptr < std::vector<signed char> > {
+    static int asptr(SEXP obj, std::vector<signed char> **val) {
+      std::vector<signed char> *p;
+      // not sure how to check the size of the SEXP obj is correct
+      int sexpsz = Rf_length(obj);
+      p = new std::vector<signed char>(sexpsz);
+      SEXP coerced;
+      PROTECT(coerced = Rf_coerceVector(obj, INTSXP));
+      int *S = INTEGER_POINTER(coerced);
+      for (unsigned pos = 0; pos < p->size(); pos++)
+        {
+          (*p)[pos] = static_cast<signed char>(S[pos]);
+        }
+      int res = SWIG_OK;
+      if (SWIG_IsOK(res)) {
+        if (val) *val = p;
+      }
+      UNPROTECT(1);
+      return res;
+    }
+  };
+
+   // 16 bit integer types
+    template <>
+  struct traits_asptr < std::vector<unsigned short int> > {
+    static int asptr(SEXP obj, std::vector<unsigned short int> **val) {
+      std::vector<unsigned short int> *p;
+      unsigned int sexpsz = Rf_length(obj);
+      p = new std::vector<unsigned short int>(sexpsz);
+      SEXP coerced;
+      PROTECT(coerced = Rf_coerceVector(obj, INTSXP));
+      int *S = INTEGER_POINTER(coerced);
+      for (unsigned pos = 0; pos < p->size(); pos++)
+        {
+          (*p)[pos] = static_cast<unsigned short int>(S[pos]);
+        }
+      int res = SWIG_OK;
+      if (SWIG_IsOK(res)) {
+        if (val) *val = p;
+      }
+      UNPROTECT(1);
+      return res;
+    }
+  };
+
+    template <>
+  struct traits_asptr < std::vector<short int> > {
+    static int asptr(SEXP obj, std::vector<short int> **val) {
+      std::vector<short int> *p;
+      // not sure how to check the size of the SEXP obj is correct
+      int sexpsz = Rf_length(obj);
+      p = new std::vector<short int>(sexpsz);
+      SEXP coerced;
+      PROTECT(coerced = Rf_coerceVector(obj, INTSXP));
+      int *S = INTEGER_POINTER(coerced);
+      for (unsigned pos = 0; pos < p->size(); pos++)
+        {
+          (*p)[pos] = static_cast<short int>(S[pos]);
+        }
+      int res = SWIG_OK;
+      if (SWIG_IsOK(res)) {
+        if (val) *val = p;
+      }
+      UNPROTECT(1);
+      return res;
+    }
+  };
+    // 32 bit integer types
+    template <>
+  struct traits_asptr < std::vector<unsigned int> > {
+    static int asptr(SEXP obj, std::vector<unsigned int> **val) {
+      std::vector<unsigned int> *p;
+      unsigned int sexpsz = Rf_length(obj);
+      p = new std::vector<unsigned int>(sexpsz);
+      SEXP coerced;
+      PROTECT(coerced = Rf_coerceVector(obj, INTSXP));
+      int *S = INTEGER_POINTER(coerced);
+      for (unsigned pos = 0; pos < p->size(); pos++)
+        {
+          (*p)[pos] = static_cast<unsigned int>(S[pos]);
+        }
+      int res = SWIG_OK;
+      if (SWIG_IsOK(res)) {
+        if (val) *val = p;
+      }
+      UNPROTECT(1);
+      return res;
+    }
+  };
+
+    template <>
+  struct traits_asptr < std::vector<int> > {
+    static int asptr(SEXP obj, std::vector<int> **val) {
+      std::vector<int> *p;
+      // not sure how to check the size of the SEXP obj is correct
+      int sexpsz = Rf_length(obj);
+      p = new std::vector<int>(sexpsz);
+      SEXP coerced;
+      PROTECT(coerced = Rf_coerceVector(obj, INTSXP));
+      int *S = INTEGER_POINTER(coerced);
+      for (unsigned pos = 0; pos < p->size(); pos++)
+        {
+          (*p)[pos] = static_cast<int>(S[pos]);
+        }
+      int res = SWIG_OK;
+      if (SWIG_IsOK(res)) {
+        if (val) *val = p;
+      }
+      UNPROTECT(1);
+      return res;
+    }
+  };
+
+#if defined(SWIGWORDSIZE64)
+    // 64 bit integer types
+    template <>
+  struct traits_asptr < std::vector<unsigned long int> > {
+    static int asptr(SEXP obj, std::vector<unsigned long int> **val) {
+      std::vector<unsigned long int> *p;
+      unsigned int sexpsz = Rf_length(obj);
+      p = new std::vector<unsigned long int>(sexpsz);
+      SEXP coerced;
+      PROTECT(coerced = Rf_coerceVector(obj, INTSXP));
+      int *S = INTEGER_POINTER(coerced);
+      for (unsigned pos = 0; pos < p->size(); pos++)
+        {
+          (*p)[pos] = static_cast<unsigned long int>(S[pos]);
+        }
+      int res = SWIG_OK;
+      if (SWIG_IsOK(res)) {
+        if (val) *val = p;
+      }
+      UNPROTECT(1);
+      return res;
+    }
+  };
+
+    template <>
+  struct traits_asptr < std::vector<long int> > {
+    static int asptr(SEXP obj, std::vector<long int> **val) {
+      std::vector<long int> *p;
+      // not sure how to check the size of the SEXP obj is correct
+      int sexpsz = Rf_length(obj);
+      p = new std::vector<long int>(sexpsz);
+      SEXP coerced;
+      PROTECT(coerced = Rf_coerceVector(obj, INTSXP));
+      int *S = INTEGER_POINTER(coerced);
+      for (unsigned pos = 0; pos < p->size(); pos++)
+        {
+          (*p)[pos] = static_cast<long int>(S[pos]);
+        }
+      int res = SWIG_OK;
+      if (SWIG_IsOK(res)) {
+        if (val) *val = p;
+      }
+      UNPROTECT(1);
+      return res;
+    }
+  };
+
+#else
+    // 64 bit integer types
+    template <>
+  struct traits_asptr < std::vector<unsigned long long int> > {
+    static int asptr(SEXP obj, std::vector<unsigned long long int> **val) {
+      std::vector<unsigned long long int> *p;
+      unsigned int sexpsz = Rf_length(obj);
+      p = new std::vector<unsigned long long int>(sexpsz);
+      SEXP coerced;
+      PROTECT(coerced = Rf_coerceVector(obj, INTSXP));
+      int *S = INTEGER_POINTER(coerced);
+      for (unsigned pos = 0; pos < p->size(); pos++)
+        {
+          (*p)[pos] = static_cast<unsigned long long int>(S[pos]);
+        }
+      int res = SWIG_OK;
+      if (SWIG_IsOK(res)) {
+        if (val) *val = p;
+      }
+      UNPROTECT(1);
+      return res;
+    }
+  };
+
+    template <>
+  struct traits_asptr < std::vector<long long int> > {
+    static int asptr(SEXP obj, std::vector<long long int> **val) {
+      std::vector<long long int> *p;
+      // not sure how to check the size of the SEXP obj is correct
+      int sexpsz = Rf_length(obj);
+      p = new std::vector<long long int>(sexpsz);
+      SEXP coerced;
+      PROTECT(coerced = Rf_coerceVector(obj, INTSXP));
+      int *S = INTEGER_POINTER(coerced);
+      for (unsigned pos = 0; pos < p->size(); pos++)
+        {
+          (*p)[pos] = static_cast<long long int>(S[pos]);
+        }
+      int res = SWIG_OK;
+      if (SWIG_IsOK(res)) {
+        if (val) *val = p;
+      }
+      UNPROTECT(1);
+      return res;
+    }
+  };
+
+#endif
+
+    template <>
+  struct traits_asptr < std::vector<bool> > {
+    static int asptr(SEXP obj, std::vector<bool> **val) {
+      std::vector<bool> *p;
+      // not sure how to check the size of the SEXP obj is correct
+      int sexpsz = Rf_length(obj);
+      p = new std::vector<bool>(sexpsz);
+      SEXP coerced;
+      PROTECT(coerced = Rf_coerceVector(obj, LGLSXP));
+      int *S = LOGICAL_POINTER(coerced);
+      for (unsigned pos = 0; pos < p->size(); pos++)
+        {
+          (*p)[pos] = static_cast<bool>(S[pos]);
+        }
+      int res = SWIG_OK;
+      if (SWIG_IsOK(res)) {
+        if (val) *val = p;
+      }
+      UNPROTECT(1);
+      return res;
+    }
+  };
+
+    template <>
+      struct traits_asptr < std::vector<std::basic_string<char> > > {
+      static int asptr(SEXP obj, std::vector<std::basic_string<char> > **val) {
+	std::vector<std::basic_string<char> > *p;
+      // R character vectors are STRSXP containing CHARSXP
+      // access a CHARSXP using STRING_ELT
+      int sexpsz = Rf_length(obj);
+      p = new std::vector<std::basic_string<char> >(sexpsz);
+      SEXP coerced;
+      PROTECT(coerced = Rf_coerceVector(obj, STRSXP));
+      //SEXP *S = CHARACTER_POINTER(coerced);
+      for (unsigned pos = 0; pos < p->size(); pos++)
+        {
+	  const char * thecstring = CHAR(STRING_ELT(coerced, pos));
+          (*p)[pos] = std::basic_string<char>(thecstring);
+        }
+      int res = SWIG_OK;
+      if (SWIG_IsOK(res)) {
+        if (val) *val = p;
+      }
+      UNPROTECT(1);
+      return res;
+    }
+  };
+
+    // catchall for R to vector conversion
+  template <typename T>
+  struct traits_asptr < std::vector<T> > {
+    static int asptr(SEXP obj, std::vector<T> **val) {
+      std::vector<T> *p;
+      int res = SWIG_R_ConvertPtr(obj, (void**)&p, type_info< std::vector<T> >(), 0);
+      if (SWIG_IsOK(res)) {
+        if (val) *val = p;
+      }
+      return res;
+    }
+  };
+
+  // now for vectors of vectors. These will be represented as lists of vectors on the
+  // catch all that does everything with vectors
+  template <>
+    struct traits_from_ptr<std::vector<std::vector<unsigned int> > > {
+      static SEXP from (std::vector< std::vector<unsigned int> > *val, int owner = 0) {
+        SEXP result;
+        // allocate the R list
+        PROTECT(result = Rf_allocVector(VECSXP, val->size()));
+        for (unsigned pos = 0; pos < val->size(); pos++)
+          {
+            // allocate the R vector
+            SET_VECTOR_ELT(result, pos, Rf_allocVector(INTSXP, val->at(pos).size()));
+            // Fill the R vector
+            for (unsigned vpos = 0; vpos < val->at(pos).size(); ++vpos)
+              {
+                INTEGER_POINTER(VECTOR_ELT(result, pos))[vpos] = static_cast<int>(val->at(pos).at(vpos));
+              }
+          }
+        UNPROTECT(1);
+        return(result);
+      }
+    };
+
+
+  template <>
+    struct traits_from_ptr<std::vector<std::vector<int> > > {
+      static SEXP from (std::vector< std::vector<int > > *val, int owner = 0) {
+        SEXP result;
+        // allocate the R list
+        PROTECT(result = Rf_allocVector(VECSXP, val->size()));
+        for (unsigned pos = 0; pos < val->size(); pos++)
+          {
+            // allocate the R vector
+            SET_VECTOR_ELT(result, pos, Rf_allocVector(INTSXP, val->at(pos).size()));
+            // Fill the R vector
+            for (unsigned vpos = 0; vpos < val->at(pos).size(); ++vpos)
+              {
+                INTEGER_POINTER(VECTOR_ELT(result, pos))[vpos] = static_cast<int>(val->at(pos).at(vpos));
+              }
+          }
+        UNPROTECT(1);
+        return(result);
+      }
+    };
+
+  template <>
+    struct traits_from_ptr<std::vector<std::vector<float> > > {
+      static SEXP from (std::vector< std::vector<float > > *val, int owner = 0) {
+        SEXP result;
+        // allocate the R list
+        PROTECT(result = Rf_allocVector(VECSXP, val->size()));
+        for (unsigned pos = 0; pos < val->size(); pos++)
+          {
+            // allocate the R vector
+            SET_VECTOR_ELT(result, pos, Rf_allocVector(REALSXP, val->at(pos).size()));
+            // Fill the R vector
+            for (unsigned vpos = 0; vpos < val->at(pos).size(); ++vpos)
+              {
+                NUMERIC_POINTER(VECTOR_ELT(result, pos))[vpos] = static_cast<double>(val->at(pos).at(vpos));
+              }
+          }
+        UNPROTECT(1);
+        return(result);
+      }
+    };
+
+  template <>
+    struct traits_from_ptr<std::vector<std::vector<double> > > {
+      static SEXP from (std::vector< std::vector<double > > *val, int owner = 0) {
+        SEXP result;
+        // allocate the R list
+        PROTECT(result = Rf_allocVector(VECSXP, val->size()));
+        for (unsigned pos = 0; pos < val->size(); pos++)
+          {
+            // allocate the R vector
+            SET_VECTOR_ELT(result, pos, Rf_allocVector(REALSXP, val->at(pos).size()));
+            // Fill the R vector
+            for (unsigned vpos = 0; vpos < val->at(pos).size(); ++vpos)
+              {
+                NUMERIC_POINTER(VECTOR_ELT(result, pos))[vpos] = static_cast<double>(val->at(pos).at(vpos));
+              }
+          }
+        UNPROTECT(1);
+        return(result);
+      }
+    };
+
+  template <>
+    struct traits_from_ptr<std::vector<std::vector<bool> > > {
+      static SEXP from (std::vector< std::vector<bool> > *val, int owner = 0) {
+        SEXP result;
+        // allocate the R list
+        PROTECT(result = Rf_allocVector(VECSXP, val->size()));
+        for (unsigned pos = 0; pos < val->size(); pos++)
+          {
+            // allocate the R vector
+            SET_VECTOR_ELT(result, pos, Rf_allocVector(LGLSXP, val->at(pos).size()));
+            // Fill the R vector
+            for (unsigned vpos = 0; vpos < val->at(pos).size(); ++vpos)
+              {
+                LOGICAL_POINTER(VECTOR_ELT(result, pos))[vpos] = (val->at(pos).at(vpos));
+              }
+          }
+        UNPROTECT(1);
+        return(result);
+      }
+    };
+
+  template <typename T>
+    struct traits_from_ptr< std::vector < std::vector< T > > > {
+    static SEXP from (std::vector < std::vector< T > > *val, int owner = 0) {
+      return SWIG_R_NewPointerObj(val, type_info< std::vector < std::vector< T > > >(), owner);
+    }
+  };
+
+  /////////////////////////////////////////////////////////////////
+
+  // R side
+  template <>
+    struct traits_asptr < std::vector< std::vector<unsigned int> > > {
+    static int asptr(SEXP obj, std::vector< std::vector<unsigned int> > **val) {
+      std::vector <std::vector<unsigned int> > *p;
+      // this is the length of the list
+      unsigned int sexpsz = Rf_length(obj);
+      p = new std::vector< std::vector<unsigned int> > (sexpsz);
+
+      for (unsigned listpos = 0; listpos < sexpsz; ++listpos)
+        {
+          unsigned vecsize = Rf_length(VECTOR_ELT(obj, listpos));
+          for (unsigned vpos = 0; vpos < vecsize; ++vpos)
+            {
+              (*p)[listpos].push_back(static_cast<int>(INTEGER_POINTER(VECTOR_ELT(obj, listpos))[vpos]));
+            }
+        }
+
+      int res = SWIG_OK;
+
+      if (SWIG_IsOK(res)) {
+        if (val) *val = p;
+      }
+      return res;
+    }
+  };
+
+  template <>
+    struct traits_asptr < std::vector< std::vector< int> > > {
+    static int asptr(SEXP obj, std::vector< std::vector< int> > **val) {
+      std::vector <std::vector< int> > *p;
+      // this is the length of the list
+      unsigned int sexpsz = Rf_length(obj);
+      p = new std::vector< std::vector< int> > (sexpsz);
+
+      for (unsigned listpos = 0; listpos < sexpsz; ++listpos)
+        {
+          unsigned vecsize = Rf_length(VECTOR_ELT(obj, listpos));
+          for (unsigned vpos = 0; vpos < vecsize; ++vpos)
+            {
+              (*p)[listpos].push_back(static_cast<int>(INTEGER_POINTER(VECTOR_ELT(obj, listpos))[vpos]));
+            }
+        }
+
+      int res = SWIG_OK;
+
+      if (SWIG_IsOK(res)) {
+        if (val) *val = p;
+      }
+      return res;
+    }
+  };
+
+  template <>
+    struct traits_asptr < std::vector< std::vector< float> > > {
+    static int asptr(SEXP obj, std::vector< std::vector< float> > **val) {
+      std::vector <std::vector< float> > *p;
+      // this is the length of the list
+      unsigned int sexpsz = Rf_length(obj);
+      p = new std::vector< std::vector< float> > (sexpsz);
+
+      for (unsigned listpos = 0; listpos < sexpsz; ++listpos)
+        {
+          unsigned vecsize = Rf_length(VECTOR_ELT(obj, listpos));
+          for (unsigned vpos = 0; vpos < vecsize; ++vpos)
+            {
+              (*p)[listpos].push_back(static_cast<float>(NUMERIC_POINTER(VECTOR_ELT(obj, listpos))[vpos]));
+            }
+        }
+
+      int res = SWIG_OK;
+
+      if (SWIG_IsOK(res)) {
+        if (val) *val = p;
+      }
+      return res;
+    }
+  };
+
+  template <>
+    struct traits_asptr < std::vector< std::vector< double> > > {
+    static int asptr(SEXP obj, std::vector< std::vector< double> > **val) {
+      std::vector <std::vector< double> > *p;
+      // this is the length of the list
+      unsigned int sexpsz = Rf_length(obj);
+      p = new std::vector< std::vector< double> > (sexpsz);
+
+      for (unsigned listpos = 0; listpos < sexpsz; ++listpos)
+        {
+          unsigned vecsize = Rf_length(VECTOR_ELT(obj, listpos));
+          for (unsigned vpos = 0; vpos < vecsize; ++vpos)
+            {
+              (*p)[listpos].push_back(static_cast<double>(NUMERIC_POINTER(VECTOR_ELT(obj, listpos))[vpos]));
+            }
+        }
+
+      int res = SWIG_OK;
+
+      if (SWIG_IsOK(res)) {
+        if (val) *val = p;
+      }
+      return res;
+    }
+  };
+
+  template <>
+    struct traits_asptr < std::vector< std::vector< bool > > > {
+    static int asptr(SEXP obj, std::vector< std::vector< bool> > **val) {
+      std::vector <std::vector< bool > > *p;
+      // this is the length of the list
+      unsigned int sexpsz = Rf_length(obj);
+      p = new std::vector< std::vector< bool > > (sexpsz);
+
+      for (unsigned listpos = 0; listpos < sexpsz; ++listpos)
+        {
+          unsigned vecsize = Rf_length(VECTOR_ELT(obj, listpos));
+          for (unsigned vpos = 0; vpos < vecsize; ++vpos)
+            {
+              (*p)[listpos].push_back(static_cast<bool>(LOGICAL_POINTER(VECTOR_ELT(obj, listpos))[vpos]));
+            }
+        }
+
+      int res = SWIG_OK;
+
+      if (SWIG_IsOK(res)) {
+        if (val) *val = p;
+      }
+      return res;
+    }
+  };
+
+  //  catchall
+  template <typename T>
+    struct traits_asptr < std::vector< std::vector<T> > > {
+    static int asptr(SEXP obj, std::vector< std::vector<T> > **val) {
+      std::vector< std::vector<T> > *p;
+      Rprintf("vector of vectors - unsupported content\n");
+      int res = SWIG_R_ConvertPtr(obj, (void**)&p, type_info< std::vector< std::vector<T> > > (), 0);
+      if (SWIG_IsOK(res)) {
+        if (val) *val = p;
+      }
+      return res;
+    }
+  };
+
+  }
+%}
+
+#define %swig_vector_methods(Type...) %swig_sequence_methods(Type)
+#define %swig_vector_methods_val(Type...) %swig_sequence_methods_val(Type);
+
+%define %traits_type_name(Type...)
+%fragment(SWIG_Traits_frag(Type), "header",
+          fragment="StdTraits",fragment="StdVectorTraits") {
+  namespace swig {
+    template <>  struct traits< Type > {
+      typedef pointer_category category;
+      static const char* type_name() {
+        return #Type;
+      }
+    };
+  }
+ }
+%enddef
+
+%include <std/std_vector.i>
+
+%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<double>)
+%traits_type_name(std::vector<double>)
+%typemap("rtypecheck") std::vector<double>, std::vector<double> *, std::vector<double> &
+    %{ is.numeric($arg) %}
+%typemap("rtype") std::vector<double> "numeric"
+%typemap("scoercein") std::vector<double>, std::vector<double> *, std::vector<double> & "$input = as.numeric($input);";
+
+%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<float>)
+%traits_type_name(std::vector<float>)
+
+// reuse these for float
+%typemap("rtype") std::vector<float>, std::vector<float> *, std::vector<float> & = std::vector<double>;
+%typemap("rtypecheck") std::vector<float>, std::vector<float> *, std::vector<float> & = std::vector<double>;
+%typemap("scoercein") std::vector<float>, std::vector<float> *, std::vector<float> & = std::vector<double>;
+
+
+%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<bool>);
+%traits_type_name(std::vector<bool>);
+%typemap("rtypecheck") std::vector<bool>, std::vector<bool> *, std::vector<bool> &
+   %{ is.logical($arg) %}
+%typemap("rtype") std::vector<bool> "logical"
+%typemap("scoercein") std::vector<bool> , std::vector<bool> & "$input = as.logical($input);";
+
+
+%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<int>);
+%traits_type_name(std::vector<int>);
+%typemap("rtypecheck") std::vector<int>, std::vector<int>  *, std::vector<int>  &
+   %{ is.integer($arg) || is.numeric($arg) %}
+
+%typemap("rtype") std::vector<int> "integer"
+%typemap("scoercein") std::vector<int> , std::vector<int> *, std::vector<int> & "$input = as.integer($input);";
+
+// strings
+%typemap("rtype") std::vector< std::basic_string<char> >,  
+std::vector< std::basic_string<char> > *,
+   std::vector< std::basic_string<char> > & "character"
+
+%typemap("rtypecheck") std::vector< std::basic_string<char> >,  
+std::vector< std::basic_string<char> > *,
+   std::vector< std::basic_string<char> > &
+   %{ is.character($arg) %}
+
+%typemap("scoercein") std::vector< std::basic_string<char> >,  
+std::vector< std::basic_string<char> > *,
+   std::vector< std::basic_string<char> > & "$input = as.character($input);";
+
+%typemap("scoerceout") std::vector< std::basic_string<char> >,  
+std::vector< std::basic_string<char> > *,
+   std::vector< std::basic_string<char> > & 
+%{    %}
+
+%apply std::vector< std::basic_string<char> > { std::vector< std::string> };
+
+// all the related integer vectors
+// signed
+%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<signed char>);
+%traits_type_name(std::vector<signed char>);
+
+%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<signed short>);
+%traits_type_name(std::vector<signed short>);
+
+#if defined(SWIGWORDSIZE64)
+%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<long int>);
+%traits_type_name(std::vector<long int>);
+#else
+%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<long long int>);
+%traits_type_name(std::vector<long long int>);
+#endif
+
+// unsigned
+%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<unsigned char>);
+%traits_type_name(std::vector<unsigned char>);
+
+%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<unsigned short>);
+%traits_type_name(std::vector<unsigned short>);
+
+%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<unsigned int>);
+%traits_type_name(std::vector<unsigned int>);
+
+#if defined(SWIGWORDSIZE64)
+%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<unsigned long int>);
+%traits_type_name(std::vector<unsigned long int>);
+#else
+%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<unsigned long long int>);
+%traits_type_name(std::vector<unsigned long long int>);
+#endif
+
+// These R side typemaps are common for integer types
+// but we can't use %apply as it will copy the C side ones too
+// Also note that we don't seem to be able to use types like
+// int_least8_t here.
+%typemap("rtype") std::vector<signed char>, std::vector<signed char> *, std::vector<signed char> & = std::vector<int>;
+%typemap("rtype") std::vector<signed short>, std::vector<signed short> *, std::vector<signed short> & = std::vector<int>;
+%typemap("rtype") std::vector<unsigned char>, std::vector<unsigned char> *, std::vector<unsigned char> & = std::vector<int>;
+%typemap("rtype") std::vector<unsigned int>, std::vector<unsigned int> *, std::vector<unsigned int> & = std::vector<int>;
+
+#if defined(SWIGWORDSIZE64)
+%typemap("rtype") std::vector<long int>, std::vector<long int> *, std::vector<long int> & = std::vector<int>;
+%typemap("rtype") std::vector<unsigned long int>, std::vector<unsigned long int> *, std::vector<unsigned long int> & = std::vector<int>;
+#else
+%typemap("rtype") std::vector<long long int>, std::vector<long long int> *, std::vector<long long int> & = std::vector<int>;
+%typemap("rtype") std::vector<unsigned long long int>, std::vector<unsigned long long int> *, std::vector<unsigned long long int> & = std::vector<int>;
+#endif
+
+
+%typemap("scoercein") std::vector<signed char>, std::vector<signed char> *, std::vector<signed char> & = std::vector<int>;
+%typemap("scoercein") std::vector<signed short>, std::vector<signed short> *, std::vector<signed short> & = std::vector<int>;
+%typemap("scoercein") std::vector<unsigned char>, std::vector<unsigned char> *, std::vector<unsigned char> & = std::vector<int>;
+%typemap("scoercein") std::vector<unsigned int>, std::vector<unsigned int> *, std::vector<unsigned int> & = std::vector<int>;
+
+#if defined(SWIGWORDSIZE64)
+%typemap("scoercein") std::vector<long int>, std::vector<long int> *, std::vector<long int> & = std::vector<int>;
+%typemap("scoercein") std::vector<unsigned long int>, std::vector<unsigned long int> *, std::vector<unsigned long int> & = std::vector<int>;
+#else
+%typemap("scoercein") std::vector<long long int>, std::vector<long long int> *, std::vector<long long int> & = std::vector<int>;
+%typemap("scoercein") std::vector<unsigned long long int>, std::vector<unsigned long long int> *, std::vector<unsigned long long int> & = std::vector<int>;
+#endif
+
+%typemap("rtypecheck") std::vector<signed char>, std::vector<signed char> *, std::vector<signed char> & = std::vector<int>;
+%typemap("rtypecheck") std::vector<signed short>, std::vector<signed short> *, std::vector<signed short> & = std::vector<int>;
+%typemap("rtypecheck") std::vector<unsigned char>, std::vector<unsigned char> *, std::vector<unsigned char> & = std::vector<int>;
+%typemap("rtypecheck") std::vector<unsigned int>, std::vector<unsigned int> *, std::vector<unsigned int> & = std::vector<int>;
+
+#if defined(SWIGWORDSIZE64)
+%typemap("rtypecheck") std::vector<long int>, std::vector<long int> *, std::vector<long int> &  = std::vector<int>;
+%typemap("rtypecheck") std::vector<unsigned long int>, std::vector<unsigned long int> *, std::vector<unsigned long int> & = std::vector<int>;
+#else
+%typemap("rtypecheck") std::vector<long long int>, std::vector<long long int> *, std::vector<long long int> & = std::vector<int>;
+%typemap("rtypecheck") std::vector<unsigned long long int>, std::vector<unsigned long long int> *, std::vector<unsigned long long int> & = std::vector<int>;
+#endif
+
+///////////////////////////////////////////////////////////////
+
+%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<std::vector<int> >);
+%traits_type_name(std::vector< std::vector<int> >);
+%typemap("rtypecheck") std::vector<std::vector<int> >, std::vector<std::vector<int> > *, std::vector<std::vector<int> > &
+   %{ is.list($arg) && all(sapply($arg , is.integer) || sapply($arg, is.numeric)) %}
+%typemap("rtype") std::vector<std::vector<int> >, std::vector<std::vector<int> > *, std::vector<std::vector<int> > & "list"
+%typemap("scoercein") std::vector< std::vector<int> >, std::vector<std::vector<int> > *, std::vector<std::vector<int> > & "$input = lapply($input, as.integer);";
+
+%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<std::vector<unsigned int> >);
+%traits_type_name(std::vector< std::vector<unsigned int> >);
+%typemap("rtypecheck") std::vector<std::vector<unsigned int> >, std::vector<std::vector<unsigned int> > *, std::vector<std::vector<unsigned int> > &
+   %{ is.list($arg) && all(sapply($arg , is.integer) || sapply($arg, is.numeric)) %}
+%typemap("rtype") std::vector<std::vector<unsigned int> >, std::vector<std::vector<unsigned int> > *, std::vector<std::vector<unsigned int> > & "list"
+%typemap("scoercein") std::vector< std::vector<unsigned int> >, std::vector<std::vector<int> > *, std::vector<std::vector<unsigned int> > & "$input = lapply($input, as.integer);";
+
+%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<std::vector<float> >);
+%traits_type_name(std::vector< std::vector<float> >);
+%typemap("rtypecheck") std::vector<std::vector<float> >, std::vector<std::vector<float> > *, std::vector<std::vector<float> > &
+   %{ is.list($arg) && all(sapply($arg , is.integer) || sapply($arg, is.numeric)) %}
+%typemap("rtype") std::vector<std::vector<float> >, std::vector<std::vector<float> > *, std::vector<std::vector<float> > "list"
+%typemap("scoercein") std::vector< std::vector<float> >, std::vector<std::vector<float> > *, std::vector<std::vector<float> > & "$input = lapply($input, as.numeric);";
+
+%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<std::vector<double> >);
+%traits_type_name(std::vector< std::vector<double> >);
+%typemap("rtypecheck") std::vector<std::vector<double> >, std::vector<std::vector<double> > *, std::vector<std::vector<double> > &
+   %{ is.list($arg) && all(sapply($arg , is.integer) || sapply($arg, is.numeric)) %}
+%typemap("rtype") std::vector<std::vector<double> >, std::vector<std::vector<double> > *, std::vector<std::vector<double> > & "list"
+%typemap("scoercein") std::vector< std::vector<double> >, std::vector<std::vector<double> > *, std::vector<std::vector<double> > &
+ "$input = lapply($input, as.numeric);";
+
+%typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<std::vector<bool> >);
+%traits_type_name(std::vector< std::vector<bool> >);
+%typemap("rtypecheck") std::vector<std::vector<bool> >, std::vector<std::vector<bool> > *, std::vector<std::vector<bool> > &
+   %{ is.list($arg) && all(sapply($arg , is.integer) || sapply($arg, is.numeric)) %}
+%typemap("rtype") std::vector<std::vector<bool> >, std::vector<std::vector<bool> > *, std::vector<std::vector<bool> > & "list"
+%typemap("scoercein") std::vector< std::vector<bool> >, std::vector<std::vector<bool> > *, std::vector<std::vector<bool> > & "$input = lapply($input, as.logical);";
+
+// we don't want these to be given R classes as they
+// have already been turned into R vectors.
+%typemap(scoerceout) std::vector<double>,
+   std::vector<double>*,
+   std::vector<double>&,
+   std::vector<float> ,
+   std::vector<float>*,
+   std::vector<float> ,
+   std::vector<signed char>,
+   std::vector<signed char>*,
+   std::vector<signed char>&,
+   std::vector<signed short>,
+   std::vector<signed short>*,
+   std::vector<signed short>&,
+   std::vector<int>,
+   std::vector<int>*,
+   std::vector<int>&,
+   std::vector<unsigned char>,
+   std::vector<unsigned char>*,
+   std::vector<unsigned char>&,
+   std::vector<unsigned short>,
+   std::vector<unsigned short>*,
+   std::vector<unsigned short>&,
+   std::vector<unsigned int>,
+   std::vector<unsigned int>*,
+   std::vector<unsigned int>&,
+   std::vector<bool>,
+   std::vector<bool>*,
+   std::vector<bool>&,
+ // vectors of vectors
+   std::vector< std::vector<unsigned int> >,
+   std::vector< std::vector<unsigned int> >*,
+   std::vector< std::vector<unsigned int> >&,
+   std::vector< std::vector<int> >,
+   std::vector< std::vector<int> >*,
+   std::vector< std::vector<int> >&,
+   std::vector< std::vector<float> >,
+   std::vector< std::vector<float> >*,
+   std::vector< std::vector<float> >&,
+   std::vector< std::vector<double> >,
+   std::vector< std::vector<double> >*,
+   std::vector< std::vector<double> >&,
+   std::vector< std::vector<bool> >,
+   std::vector< std::vector<bool> >*,
+   std::vector< std::vector<bool> >&
+ %{    %}
+
+#if defined(SWIGWORDSIZE64)
+%typemap(scoerceout) std::vector<long int>,
+   std::vector<long int>*,
+   std::vector<long int>&,
+   std::vector<unsigned long int>,
+   std::vector<unsigned long int>*,
+   std::vector<unsigned long int>&
+ %{    %}
+#else
+
+%typemap(scoerceout) std::vector<long long int>,
+   std::vector<long long int>*,
+   std::vector<long long int>&,
+   std::vector<unsigned long long int>,
+   std::vector<unsigned long long int>*,
+   std::vector<unsigned long long int>&
+ %{    %}
+
+#endif
diff --git a/share/swig/2.0.11/r/stl.i b/share/swig/3.0.12/r/stl.i
index 37e2ccb..37e2ccb 100644
--- a/share/swig/2.0.11/r/stl.i
+++ b/share/swig/3.0.12/r/stl.i
diff --git a/share/swig/2.0.11/r/typemaps.i b/share/swig/3.0.12/r/typemaps.i
index 1f9b9c4..1f9b9c4 100644
--- a/share/swig/2.0.11/r/typemaps.i
+++ b/share/swig/3.0.12/r/typemaps.i
diff --git a/share/swig/3.0.12/ruby/Makefile.swig b/share/swig/3.0.12/ruby/Makefile.swig
new file mode 100644
index 0000000..648b321
--- /dev/null
+++ b/share/swig/3.0.12/ruby/Makefile.swig
@@ -0,0 +1,42 @@
+# File : Makefile.swig
+# Makefile for a SWIG module.  Use this file if you are
+# producing a Ruby extension for general use or distribution.
+#
+# 1.  Prepare extconf.rb.
+# 2.  Modify this file as appropriate.
+# 3.  Type 'make -f Makefile.swig' to generate wrapper code and Makefile.
+# 4.  Type 'make' to build your extension.
+# 5.  Type 'make install' to install your extension.
+#
+
+MODULE    = yourmodule
+FEATURE   = $(MODULE)
+INTERFACE = $(MODULE).i
+RUBY      = ruby
+SWIG      = swig
+
+# for C extension
+SWIGOPT   = -ruby
+WRAPPER   = $(MODULE)_wrap.c
+
+## for C++ extension
+#SWIGOPT   = -ruby -c++
+#WRAPPER   = $(MODULE)_wrap.cc
+
+
+swigall: $(WRAPPER) Makefile
+
+$(WRAPPER): $(INTERFACE)
+	$(SWIG) $(SWIGOPT) -o $@ $(INTERFACE)
+
+Makefile: extconf.rb
+	$(RUBY) extconf.rb
+	@if [ -f Makefile ] ; then\
+		echo "include Makefile.swig" >> Makefile;\
+	fi
+
+swigclean:
+	@if [ -f Makefile ] ; then\
+		make -f Makefile clean;\
+	fi
+	rm -f Makefile $(WRAPPER)
diff --git a/share/swig/2.0.11/ruby/argcargv.i b/share/swig/3.0.12/ruby/argcargv.i
index fc0bc40..fc0bc40 100644
--- a/share/swig/2.0.11/ruby/argcargv.i
+++ b/share/swig/3.0.12/ruby/argcargv.i
diff --git a/share/swig/2.0.11/ruby/attribute.i b/share/swig/3.0.12/ruby/attribute.i
index 779716c..779716c 100644
--- a/share/swig/2.0.11/ruby/attribute.i
+++ b/share/swig/3.0.12/ruby/attribute.i
diff --git a/share/swig/3.0.12/ruby/boost_shared_ptr.i b/share/swig/3.0.12/ruby/boost_shared_ptr.i
new file mode 100644
index 0000000..938074d
--- /dev/null
+++ b/share/swig/3.0.12/ruby/boost_shared_ptr.i
@@ -0,0 +1,323 @@
+%include <shared_ptr.i>
+
+// Set SHARED_PTR_DISOWN to $disown if required, for example
+// #define SHARED_PTR_DISOWN $disown
+#if !defined(SHARED_PTR_DISOWN)
+#define SHARED_PTR_DISOWN 0
+#endif
+
+%fragment("SWIG_null_deleter_python", "header", fragment="SWIG_null_deleter") {
+%#define SWIG_NO_NULL_DELETER_SWIG_BUILTIN_INIT
+}
+
+// Language specific macro implementing all the customisations for handling the smart pointer
+%define SWIG_SHARED_PTR_TYPEMAPS(CONST, TYPE...)
+
+// %naturalvar is as documented for member variables
+%naturalvar TYPE;
+%naturalvar SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
+
+// destructor wrapper customisation
+%feature("unref") TYPE
+  %{(void)arg1;
+    delete reinterpret_cast< SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > * >(self);%}
+
+// Typemap customisations...
+
+// plain value
+%typemap(in) CONST TYPE (void *argp, int res = 0) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum);
+  }
+  if (!argp) {
+    %argument_nullref("$type", $symname, $argnum);
+  } else {
+    $1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
+    if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+  }
+}
+%typemap(out) CONST TYPE {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) CONST TYPE {
+  void *argp = 0;
+  swig_ruby_owntype newmem = {0, 0};
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  if (!argp) {
+    %variable_nullref("$type", "$name");
+  } else {
+    $1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
+    if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+  }
+}
+%typemap(varout) CONST TYPE {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+// plain pointer
+// Note: $disown not implemented by default as it will lead to a memory leak of the shared_ptr instance
+%typemap(in) CONST TYPE * (void  *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SHARED_PTR_DISOWN | %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum);
+  }
+  if (newmem.own & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast(tempshared.get(), $1_ltype);
+  } else {
+    smartarg = %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
+  }
+}
+
+%typemap(out, fragment="SWIG_null_deleter_python") CONST TYPE * {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), $owner | SWIG_POINTER_OWN));
+}
+
+%typemap(varin) CONST TYPE * {
+  void *argp = 0;
+  swig_ruby_owntype newmem = {0, 0};
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0;
+  if (newmem.own & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast(tempshared.get(), $1_ltype);
+  } else {
+    smartarg = %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
+  }
+}
+%typemap(varout, fragment="SWIG_null_deleter_python") CONST TYPE * {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_0) : 0;
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+// plain reference
+%typemap(in) CONST TYPE & (void  *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum);
+  }
+  if (!argp) { %argument_nullref("$type", $symname, $argnum); }
+  if (newmem.own & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast(tempshared.get(), $1_ltype);
+  } else {
+    $1 = %const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
+  }
+}
+%typemap(out, fragment="SWIG_null_deleter_python") CONST TYPE & {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner);
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) CONST TYPE & {
+  void *argp = 0;
+  swig_ruby_owntype newmem = {0, 0};
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
+  if (!argp) {
+    %variable_nullref("$type", "$name");
+  }
+  if (newmem.own & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = *%const_cast(tempshared.get(), $1_ltype);
+  } else {
+    $1 = *%const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
+  }
+}
+%typemap(varout, fragment="SWIG_null_deleter_python") CONST TYPE & {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(&$1 SWIG_NO_NULL_DELETER_0);
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+// plain pointer by reference
+// Note: $disown not implemented by default as it will lead to a memory leak of the shared_ptr instance
+%typemap(in) TYPE *CONST& (void  *argp = 0, int res = 0, $*1_ltype temp = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SHARED_PTR_DISOWN | %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum);
+  }
+  if (newmem.own & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    temp = %const_cast(tempshared.get(), $*1_ltype);
+  } else {
+    temp = %const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $*1_ltype);
+  }
+  $1 = &temp;
+}
+%typemap(out, fragment="SWIG_null_deleter_python") TYPE *CONST& {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1 SWIG_NO_NULL_DELETER_$owner);
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) TYPE *CONST& %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) TYPE *CONST& %{
+#error "varout typemap not implemented"
+%}
+
+// shared_ptr by value
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > (void *argp, int res = 0) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum);
+  }
+  if (argp) $1 = *(%reinterpret_cast(argp, $&ltype));
+  if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $&ltype);
+}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
+  swig_ruby_owntype newmem = {0, 0};
+  void *argp = 0;
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  $1 = argp ? *(%reinterpret_cast(argp, $&ltype)) : SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE >();
+  if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $&ltype);
+}
+%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+// shared_ptr by reference
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & (void *argp, int res = 0, $*1_ltype tempshared) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum);
+  }
+  if (newmem.own & SWIG_CAST_NEW_MEMORY) {
+    if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
+    delete %reinterpret_cast(argp, $ltype);
+    $1 = &tempshared;
+  } else {
+    $1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
+  }
+}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
+#error "varout typemap not implemented"
+%}
+
+// shared_ptr by pointer
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * (void *argp, int res = 0, $*1_ltype tempshared) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum);
+  }
+  if (newmem.own & SWIG_CAST_NEW_MEMORY) {
+    if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
+    delete %reinterpret_cast(argp, $ltype);
+    $1 = &tempshared;
+  } else {
+    $1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
+  }
+}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 && *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+  if ($owner) delete $1;
+}
+
+%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
+#error "varout typemap not implemented"
+%}
+
+// shared_ptr by pointer reference
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& (void *argp, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, $*1_ltype temp = 0) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum);
+  }
+  if (argp) tempshared = *%reinterpret_cast(argp, $*ltype);
+  if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $*ltype);
+  temp = &tempshared;
+  $1 = &temp;
+}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 && **$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(**$1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
+#error "varout typemap not implemented"
+%}
+
+// Typecheck typemaps
+// Note: SWIG_ConvertPtr with void ** parameter set to 0 instead of using SWIG_ConvertPtrAndOwn, so that the casting
+// function is not called thereby avoiding a possible smart pointer copy constructor call when casting up the inheritance chain.
+%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1)
+                      TYPE CONST,
+                      TYPE CONST &,
+                      TYPE CONST *,
+                      TYPE *CONST&,
+                      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 > *& {
+  int res = SWIG_ConvertPtr($input, 0, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), 0);
+  $1 = SWIG_CheckState(res);
+}
+
+
+// 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"
+%}
+
+
+%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
+
+
+%enddef
diff --git a/share/swig/2.0.11/ruby/carrays.i b/share/swig/3.0.12/ruby/carrays.i
index 8f74cd9..8f74cd9 100644
--- a/share/swig/2.0.11/ruby/carrays.i
+++ b/share/swig/3.0.12/ruby/carrays.i
diff --git a/share/swig/3.0.12/ruby/cdata.i b/share/swig/3.0.12/ruby/cdata.i
new file mode 100644
index 0000000..3679659
--- /dev/null
+++ b/share/swig/3.0.12/ruby/cdata.i
@@ -0,0 +1 @@
+%include <typemaps/cdata.swg>
diff --git a/share/swig/2.0.11/ruby/cmalloc.i b/share/swig/3.0.12/ruby/cmalloc.i
index 248f06b..248f06b 100644
--- a/share/swig/2.0.11/ruby/cmalloc.i
+++ b/share/swig/3.0.12/ruby/cmalloc.i
diff --git a/share/swig/2.0.11/ruby/cni.i b/share/swig/3.0.12/ruby/cni.i
index 10a1403..10a1403 100644
--- a/share/swig/2.0.11/ruby/cni.i
+++ b/share/swig/3.0.12/ruby/cni.i
diff --git a/share/swig/2.0.11/ruby/cpointer.i b/share/swig/3.0.12/ruby/cpointer.i
index d824792..d824792 100644
--- a/share/swig/2.0.11/ruby/cpointer.i
+++ b/share/swig/3.0.12/ruby/cpointer.i
diff --git a/share/swig/2.0.11/ruby/cstring.i b/share/swig/3.0.12/ruby/cstring.i
index ede9c59..ede9c59 100644
--- a/share/swig/2.0.11/ruby/cstring.i
+++ b/share/swig/3.0.12/ruby/cstring.i
diff --git a/share/swig/3.0.12/ruby/director.swg b/share/swig/3.0.12/ruby/director.swg
new file mode 100644
index 0000000..c6c53a3
--- /dev/null
+++ b/share/swig/3.0.12/ruby/director.swg
@@ -0,0 +1,348 @@
+/* -----------------------------------------------------------------------------
+ * director.swg
+ *
+ * This file contains support for director classes so that Ruby proxy
+ * methods can be called from C++.
+ * ----------------------------------------------------------------------------- */
+
+/*
+  Use -DSWIG_DIRECTOR_NOUEH if you prefer to avoid the use of the
+  Undefined Exception Handler provided by swig.
+*/
+#ifndef SWIG_DIRECTOR_NOUEH
+#ifndef SWIG_DIRECTOR_UEH
+#define SWIG_DIRECTOR_UEH
+#endif
+#endif
+
+#include <string>
+#include <iostream>
+#include <exception>
+#include <map>
+
+# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG)
+
+namespace Swig {
+
+  /* memory handler */
+  struct GCItem {
+    virtual ~GCItem() {
+    }
+
+    virtual swig_ruby_owntype get_own() const {
+      swig_ruby_owntype own = {0, 0};
+      return own;
+    }
+  };
+
+  struct GCItem_var {
+    GCItem_var(GCItem *item = 0) : _item(item) {
+    }
+
+    GCItem_var& operator=(GCItem *item) {
+      GCItem *tmp = _item;
+      _item = item;
+      delete tmp;
+      return *this;
+    }
+
+    ~GCItem_var() {
+      delete _item;
+    }
+
+    GCItem *operator->() const {
+      return _item;
+    }
+
+  private:
+    GCItem *_item;
+  };
+
+
+  template <typename Type>
+  struct GCItem_T : GCItem {
+    GCItem_T(Type *ptr) : _ptr(ptr) {
+    }
+
+    virtual ~GCItem_T() {
+      delete _ptr;
+    }
+
+  private:
+    Type *_ptr;
+  };
+
+  struct GCItem_Object : GCItem {
+    GCItem_Object(swig_ruby_owntype own) : _own(own) {
+    }
+
+    virtual ~GCItem_Object() {
+    }
+
+    swig_ruby_owntype get_own() const {
+      return _own;
+    }
+
+  private:
+    swig_ruby_owntype _own;
+  };
+
+  template <typename Type>
+  struct GCArray_T : GCItem {
+    GCArray_T(Type *ptr) : _ptr(ptr) {
+    }
+
+    virtual ~GCArray_T() {
+      delete[] _ptr;
+    }
+
+  private:
+    Type *_ptr;
+  };
+
+
+  /* body args */
+  struct body_args {
+    VALUE recv;
+    ID id;
+    int argc;
+    VALUE *argv;
+  };
+
+  /* Base class for director exceptions */
+  class DirectorException : public std::exception {
+  protected:
+    VALUE swig_error;
+    std::string swig_msg;
+  protected:
+    DirectorException(VALUE error) : swig_error(error) {
+    }
+
+    DirectorException(VALUE error, const char *hdr, const char *msg ="") : swig_error(error), swig_msg(hdr) {
+      if (msg[0]) {
+	swig_msg += " ";
+	swig_msg += msg;
+      }
+      if (swig_msg.size()) {
+	VALUE str = rb_str_new(swig_msg.data(), swig_msg.size());
+	swig_error = rb_exc_new3(error, str);
+      } else {
+	swig_error = error;
+      }
+    }
+
+  public:
+    virtual ~DirectorException() throw() {
+    }
+
+    VALUE getType() const {
+      return CLASS_OF(swig_error);
+    }
+
+    VALUE getError() const {
+      return swig_error;
+    }
+
+    /* Deprecated, use what() instead */
+    const std::string& getMessage() const {
+      return swig_msg;
+    }
+
+    const char *what() const throw() {
+      return swig_msg.c_str();
+    }
+  };
+
+  /* unknown exception handler  */
+  class UnknownExceptionHandler {
+#ifdef SWIG_DIRECTOR_UEH
+    static void handler() {
+      try {
+	throw;
+      } catch (DirectorException& e) {
+	std::cerr << "SWIG Director exception caught:" << std::endl
+		  << e.what() << std::endl;
+      } catch (std::exception& e) {
+	std::cerr << "std::exception caught: "<< e.what() << std::endl;
+      } catch (...) {
+	std::cerr << "Unknown exception caught." << std::endl;
+      }
+      std::cerr << std::endl
+		<< "Ruby interpreter traceback:" << std::endl;
+      std::cerr << std::endl;
+      std::cerr << "This exception was caught by the SWIG unexpected exception handler." << std::endl
+		<< "Try using %feature(\"director:except\") to avoid reaching this point." << std::endl
+		<< std::endl
+		<< "Exception is being re-thrown, program will like abort/terminate." << std::endl;
+      throw;
+    }
+
+  public:
+    std::unexpected_handler old;
+    UnknownExceptionHandler(std::unexpected_handler nh = handler) {
+      old = std::set_unexpected(nh);
+    }
+
+    ~UnknownExceptionHandler() {
+      std::set_unexpected(old);
+    }
+#endif
+  };
+
+
+  /* Type mismatch in the return value from a Ruby method call */
+  class DirectorTypeMismatchException : public DirectorException {
+  public:
+    DirectorTypeMismatchException(VALUE error, const char *msg="")
+      : DirectorException(error, "SWIG director type mismatch", msg) {
+    }
+
+    DirectorTypeMismatchException(const char *msg="")
+      : DirectorException(rb_eTypeError, "SWIG director type mismatch", msg) {
+    }
+
+    static void raise(VALUE error, const char *msg) {
+      throw DirectorTypeMismatchException(error, msg);
+    }
+
+    static void raise(const char *msg) {
+      throw DirectorTypeMismatchException(msg);
+    }
+  };
+
+  /* Any Ruby exception that occurs during a director method call */
+  class DirectorMethodException : public DirectorException {
+  public:
+    DirectorMethodException(VALUE error)
+      : DirectorException(error) {
+    }
+
+    DirectorMethodException(const char *msg = "")
+      : DirectorException(rb_eRuntimeError, "SWIG director method error.", msg) {
+    }
+
+    static void raise(VALUE error) {
+      throw DirectorMethodException(error);
+    }
+  };
+
+  /* Attempted to call a pure virtual method via a director method */
+  class DirectorPureVirtualException : public DirectorException
+  {
+  public:
+    DirectorPureVirtualException(const char *msg = "")
+      : DirectorException(rb_eRuntimeError, "SWIG director pure virtual method called", msg) {
+    }
+
+    static void raise(const char *msg) {
+      throw DirectorPureVirtualException(msg);
+    }
+  };
+
+  /* Simple thread abstraction for pthreads on win32 */
+#ifdef __THREAD__
+# define __PTHREAD__
+# if defined(_WIN32) || defined(__WIN32__)
+#  define pthread_mutex_lock EnterCriticalSection
+#  define pthread_mutex_unlock LeaveCriticalSection
+#  define pthread_mutex_t CRITICAL_SECTION
+#  define SWIG_MUTEX_INIT(var) var
+# else
+#  include <pthread.h>
+#  define SWIG_MUTEX_INIT(var) var = PTHREAD_MUTEX_INITIALIZER
+# endif
+#endif
+
+#ifdef  __PTHREAD__
+  struct Guard {
+    pthread_mutex_t *_mutex;
+
+    Guard(pthread_mutex_t &mutex) : _mutex(&mutex) {
+      pthread_mutex_lock(_mutex);
+    }
+
+    ~Guard() {
+      pthread_mutex_unlock(_mutex);
+    }
+  };
+# define SWIG_GUARD(mutex) Guard _guard(mutex)
+#else
+# define SWIG_GUARD(mutex)
+#endif
+
+  /* director base class */
+  class Director {
+  private:
+    /* pointer to the wrapped Ruby object */
+    VALUE swig_self;
+    /* flag indicating whether the object is owned by Ruby or c++ */
+    mutable bool swig_disown_flag;
+
+  public:
+    /* wrap a Ruby object. */
+    Director(VALUE self) : swig_self(self), swig_disown_flag(false) {
+    }
+
+    /* discard our reference at destruction */
+    virtual ~Director() {
+    }
+
+    /* return a pointer to the wrapped Ruby object */
+    VALUE swig_get_self() const {
+      return swig_self;
+    }
+
+    /* acquire ownership of the wrapped Ruby object (the sense of "disown" is from Ruby) */
+    void swig_disown() const {
+      if (!swig_disown_flag) {
+        swig_disown_flag = true;
+      }
+    }
+
+  /* ownership management */
+  private:
+    typedef std::map<void *, GCItem_var> swig_ownership_map;
+    mutable swig_ownership_map swig_owner;
+#ifdef __PTHREAD__
+    static pthread_mutex_t swig_mutex_own;
+#endif
+
+  public:
+    template <typename Type>
+    void swig_acquire_ownership_array(Type *vptr) const {
+      if (vptr) {
+	SWIG_GUARD(swig_mutex_own);
+	swig_owner[vptr] = new GCArray_T<Type>(vptr);
+      }
+    }
+
+    template <typename Type>
+    void swig_acquire_ownership(Type *vptr)  const {
+      if (vptr) {	
+	SWIG_GUARD(swig_mutex_own);
+	swig_owner[vptr] = new GCItem_T<Type>(vptr);
+      }
+    }
+
+    void swig_acquire_ownership_obj(void *vptr, swig_ruby_owntype own) const {
+      if (vptr && own.datafree) {
+	SWIG_GUARD(swig_mutex_own);
+	swig_owner[vptr] = new GCItem_Object(own);
+      }
+    }
+
+    swig_ruby_owntype swig_release_ownership(void *vptr) const {
+      swig_ruby_owntype own = {0, 0};
+      if (vptr) {
+	SWIG_GUARD(swig_mutex_own);
+	swig_ownership_map::iterator iter = swig_owner.find(vptr);
+	if (iter != swig_owner.end()) {
+	  own.datafree = iter->second->get_own().datafree;
+	  swig_owner.erase(iter);
+	}
+      }
+      return own;
+    }
+  };
+}
+
diff --git a/share/swig/2.0.11/ruby/embed.i b/share/swig/3.0.12/ruby/embed.i
index 9226ef4..9226ef4 100644
--- a/share/swig/2.0.11/ruby/embed.i
+++ b/share/swig/3.0.12/ruby/embed.i
diff --git a/share/swig/2.0.11/ruby/exception.i b/share/swig/3.0.12/ruby/exception.i
index 1e80d96..1e80d96 100644
--- a/share/swig/2.0.11/ruby/exception.i
+++ b/share/swig/3.0.12/ruby/exception.i
diff --git a/share/swig/2.0.11/ruby/extconf.rb b/share/swig/3.0.12/ruby/extconf.rb
index 3bac8cc..3bac8cc 100644
--- a/share/swig/2.0.11/ruby/extconf.rb
+++ b/share/swig/3.0.12/ruby/extconf.rb
diff --git a/share/swig/2.0.11/ruby/factory.i b/share/swig/3.0.12/ruby/factory.i
index 46a0a87..46a0a87 100644
--- a/share/swig/2.0.11/ruby/factory.i
+++ b/share/swig/3.0.12/ruby/factory.i
diff --git a/share/swig/3.0.12/ruby/file.i b/share/swig/3.0.12/ruby/file.i
new file mode 100644
index 0000000..f9aaa27
--- /dev/null
+++ b/share/swig/3.0.12/ruby/file.i
@@ -0,0 +1,39 @@
+// FILE *
+%{
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Ruby 1.9 changed the file name of this header */
+#ifdef HAVE_RUBY_IO_H
+#include "ruby/io.h"
+#else
+#include "rubyio.h"
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+%}
+
+%typemap(in) FILE *READ {
+    OpenFile *of;
+    GetOpenFile($input, of);
+    rb_io_check_readable(of);
+    $1 = GetReadFile(of);
+    rb_read_check($1);
+}
+
+%typemap(in) FILE *READ_NOCHECK {
+    OpenFile *of;
+    GetOpenFile($input, of);
+    rb_io_check_readable(of);
+    $1 = GetReadFile(of);
+}
+
+%typemap(in) FILE *WRITE {
+    OpenFile *of;
+    GetOpenFile($input, of);
+    rb_io_check_writable(of);
+    $1 = GetWriteFile(of);
+}
diff --git a/share/swig/2.0.11/ruby/jstring.i b/share/swig/3.0.12/ruby/jstring.i
index 17efa97..17efa97 100644
--- a/share/swig/2.0.11/ruby/jstring.i
+++ b/share/swig/3.0.12/ruby/jstring.i
diff --git a/share/swig/2.0.11/ruby/progargcargv.i b/share/swig/3.0.12/ruby/progargcargv.i
index a2843c3..a2843c3 100644
--- a/share/swig/2.0.11/ruby/progargcargv.i
+++ b/share/swig/3.0.12/ruby/progargcargv.i
diff --git a/share/swig/2.0.11/ruby/ruby.swg b/share/swig/3.0.12/ruby/ruby.swg
index efa8ec2..efa8ec2 100644
--- a/share/swig/2.0.11/ruby/ruby.swg
+++ b/share/swig/3.0.12/ruby/ruby.swg
diff --git a/share/swig/2.0.11/ruby/rubyapi.swg b/share/swig/3.0.12/ruby/rubyapi.swg
index e007757..e007757 100644
--- a/share/swig/2.0.11/ruby/rubyapi.swg
+++ b/share/swig/3.0.12/ruby/rubyapi.swg
diff --git a/share/swig/2.0.11/ruby/rubyautodoc.swg b/share/swig/3.0.12/ruby/rubyautodoc.swg
index 1e6b0d9..1e6b0d9 100644
--- a/share/swig/2.0.11/ruby/rubyautodoc.swg
+++ b/share/swig/3.0.12/ruby/rubyautodoc.swg
diff --git a/share/swig/3.0.12/ruby/rubyclasses.swg b/share/swig/3.0.12/ruby/rubyclasses.swg
new file mode 100644
index 0000000..f7b51bd
--- /dev/null
+++ b/share/swig/3.0.12/ruby/rubyclasses.swg
@@ -0,0 +1,404 @@
+#ifdef __cplusplus
+
+/*
+  GC_VALUE is used as a replacement of Ruby's VALUE.
+  GC_VALUE automatically handles registering and unregistering
+  of the underlying Ruby object with the GC.
+
+  It can be used if you want to create STL containers of VALUEs, such as:
+  
+     std::vector< GC_VALUE >;
+
+  or as a member variable:
+  
+     struct A {
+       GC_VALUE _obj;
+       A(VALUE o) : _obj(o) {
+       }
+     };
+
+   or as a input/output value (not much use for this, as VALUE works just as
+   well here, thou):
+
+     GC_VALUE func(GC_VALUE obj) { 
+       GC_VALUE out = rb_obj_classname(obj);
+       return out;
+     }
+
+
+   GC_VALUE is 'visible' at the wrapped side, so you can do:
+
+      %template(RubyVector) std::vector<swig::GC_VALUE>;
+
+   and all the proper typemaps will be used.
+   
+*/
+
+%fragment("GC_VALUE_definition","header") {
+namespace swig {
+  class SwigGCReferences {
+    VALUE _hash;
+
+    SwigGCReferences() : _hash(Qnil) {
+    }
+    ~SwigGCReferences() {
+      if (_hash != Qnil)
+        rb_gc_unregister_address(&_hash);
+    }
+    static void EndProcHandler(VALUE) {
+      // Ruby interpreter ending - _hash can no longer be accessed.
+      SwigGCReferences &s_references = instance();
+      s_references._hash = Qnil;
+    }
+  public:
+    static SwigGCReferences& instance() {
+      // Hash of all GC_VALUE's currently in use
+      static SwigGCReferences s_references;
+
+      return s_references;
+    }
+    static void initialize() {
+      SwigGCReferences &s_references = instance();
+      if (s_references._hash == Qnil) {
+        rb_set_end_proc(&EndProcHandler, Qnil);
+        s_references._hash = rb_hash_new();
+        rb_gc_register_address(&s_references._hash);
+      }
+    }
+    void GC_register(VALUE& obj) {
+      if (FIXNUM_P(obj) || SPECIAL_CONST_P(obj) || SYMBOL_P(obj))
+        return;
+      if (_hash != Qnil) {
+        VALUE val = rb_hash_aref(_hash, obj);
+        unsigned n = FIXNUM_P(val) ? NUM2UINT(val) : 0;
+        ++n;
+        rb_hash_aset(_hash, obj, INT2NUM(n));
+      }
+    }
+    void GC_unregister(const VALUE& obj) {
+      if (FIXNUM_P(obj) || SPECIAL_CONST_P(obj) || SYMBOL_P(obj))
+        return;
+      // this test should not be needed but I've noticed some very erratic
+      // behavior of none being unregistered in some very rare situations.
+      if (BUILTIN_TYPE(obj) == T_NONE)
+        return;
+      if (_hash != Qnil) {
+        VALUE val = rb_hash_aref(_hash, obj);
+        unsigned n = FIXNUM_P(val) ? NUM2UINT(val) : 1;
+        --n;
+        if (n)
+          rb_hash_aset(_hash, obj, INT2NUM(n));
+        else
+          rb_hash_delete(_hash, obj);
+      }
+    }
+  };
+
+  class GC_VALUE {
+  protected:
+    VALUE  _obj;
+
+    static ID hash_id;
+    static ID   lt_id;
+    static ID   gt_id;
+    static ID   eq_id;
+    static ID   le_id;
+    static ID   ge_id;
+
+    static ID  pos_id;
+    static ID  neg_id;
+    static ID  inv_id;
+
+    static ID  add_id;
+    static ID  sub_id;
+    static ID  mul_id;
+    static ID  div_id;
+    static ID  mod_id;
+
+    static ID  and_id;
+    static ID   or_id;
+    static ID  xor_id;
+
+    static ID  lshift_id;
+    static ID  rshift_id;
+
+    struct OpArgs
+    {
+      VALUE src;
+      ID    id;
+      int   nargs;
+      VALUE target;
+    };
+
+
+  public:
+    GC_VALUE() : _obj(Qnil)
+    {
+    }
+
+    GC_VALUE(const GC_VALUE& item) : _obj(item._obj)
+    {
+      SwigGCReferences::instance().GC_register(_obj);
+    }
+    
+    GC_VALUE(VALUE obj) :_obj(obj)
+    {
+      SwigGCReferences::instance().GC_register(_obj);
+    }
+    
+    ~GC_VALUE() 
+    {
+      SwigGCReferences::instance().GC_unregister(_obj);
+    }
+    
+    GC_VALUE & operator=(const GC_VALUE& item) 
+    {
+      SwigGCReferences::instance().GC_unregister(_obj);
+      _obj = item._obj;
+      SwigGCReferences::instance().GC_register(_obj);
+      return *this;
+    }
+
+    operator VALUE() const
+    {
+      return _obj;
+    }
+
+    VALUE inspect() const
+    {
+      return rb_inspect(_obj);
+    }
+
+    VALUE to_s() const
+    {
+      return rb_inspect(_obj);
+    }
+
+    static VALUE swig_rescue_swallow(VALUE)
+    {
+      /*
+      VALUE errstr = rb_obj_as_string(rb_errinfo());
+      printf("Swallowing error: '%s'\n", RSTRING_PTR(StringValue(errstr)));
+      */
+      return Qnil; /* Swallow Ruby exception */
+    }
+
+    static VALUE swig_rescue_funcall(VALUE p)
+    {
+      OpArgs* args = (OpArgs*) p;
+      return rb_funcall(args->src, args->id, args->nargs, args->target);
+    }
+
+    bool relational_equal_op(const GC_VALUE& other, const ID& op_id, bool (*op_func)(const VALUE& a, const VALUE& b)) const
+    {
+      if (FIXNUM_P(_obj) && FIXNUM_P(other._obj)) {
+        return op_func(_obj, other._obj);
+      }
+      bool res = false;
+      VALUE ret = Qnil;
+      SWIG_RUBY_THREAD_BEGIN_BLOCK;
+      if (rb_respond_to(_obj, op_id)) {
+        OpArgs  args;
+        args.src    = _obj;
+        args.id     = op_id;
+        args.nargs  = 1;
+        args.target = VALUE(other);
+        ret = rb_rescue(RUBY_METHOD_FUNC(swig_rescue_funcall), VALUE(&args),
+                       (RUBY_METHOD_FUNC(swig_rescue_swallow)), Qnil);
+      }
+      if (ret == Qnil) {
+        VALUE a = rb_funcall(         _obj, hash_id, 0 );
+        VALUE b = rb_funcall( VALUE(other), hash_id, 0 );
+        res = op_func(a, b);
+      } else {
+        res = RTEST(ret);
+      }
+      SWIG_RUBY_THREAD_END_BLOCK;
+      return res;
+    }
+
+    static bool operator_eq(const VALUE& a, const VALUE& b) { return a == b; }
+    static bool operator_lt(const VALUE& a, const VALUE& b) { return a < b; }
+    static bool operator_le(const VALUE& a, const VALUE& b) { return a <= b; }
+    static bool operator_gt(const VALUE& a, const VALUE& b) { return a > b; }
+    static bool operator_ge(const VALUE& a, const VALUE& b) { return a >= b; }
+
+    bool operator==(const GC_VALUE& other) const { return relational_equal_op(other, eq_id, operator_eq); }
+    bool operator<(const GC_VALUE& other) const { return relational_equal_op(other, lt_id, operator_lt); }
+    bool operator<=(const GC_VALUE& other) const { return relational_equal_op(other, le_id, operator_le); }
+    bool operator>(const GC_VALUE& other) const { return relational_equal_op(other, gt_id, operator_gt); }
+    bool operator>=(const GC_VALUE& other) const { return relational_equal_op(other, ge_id, operator_ge); }
+
+    bool operator!=(const GC_VALUE& other) const
+    {
+      return !(this->operator==(other));
+    }
+
+    GC_VALUE unary_op(const ID& op_id) const
+    {
+      VALUE ret = Qnil;
+      SWIG_RUBY_THREAD_BEGIN_BLOCK;
+      OpArgs  args;
+      args.src    = _obj;
+      args.id     = op_id;
+      args.nargs  = 0;
+      args.target = Qnil;
+      ret = rb_rescue(RUBY_METHOD_FUNC(swig_rescue_funcall), VALUE(&args),
+                     (RUBY_METHOD_FUNC(swig_rescue_swallow)), Qnil);
+      SWIG_RUBY_THREAD_END_BLOCK;
+      return ret;
+    }
+
+    GC_VALUE operator+() const { return unary_op(pos_id); }
+    GC_VALUE operator-() const { return unary_op(neg_id); }
+    GC_VALUE operator~() const { return unary_op(inv_id); }
+
+    GC_VALUE binary_op(const GC_VALUE& other, const ID& op_id) const
+    {
+      VALUE ret = Qnil;
+      SWIG_RUBY_THREAD_BEGIN_BLOCK;
+      OpArgs  args;
+      args.src    = _obj;
+      args.id     = op_id;
+      args.nargs  = 1;
+      args.target = VALUE(other);
+      ret = rb_rescue(RUBY_METHOD_FUNC(swig_rescue_funcall), VALUE(&args),
+                     (RUBY_METHOD_FUNC(swig_rescue_swallow)), Qnil);
+      SWIG_RUBY_THREAD_END_BLOCK;
+      return GC_VALUE(ret);
+    }
+
+    GC_VALUE operator+(const GC_VALUE& other) const { return binary_op(other, add_id); }
+    GC_VALUE operator-(const GC_VALUE& other) const { return binary_op(other, sub_id); }
+    GC_VALUE operator*(const GC_VALUE& other) const { return binary_op(other, mul_id); }
+    GC_VALUE operator/(const GC_VALUE& other) const { return binary_op(other, div_id); }
+    GC_VALUE operator%(const GC_VALUE& other) const { return binary_op(other, mod_id); }
+    GC_VALUE operator&(const GC_VALUE& other) const { return binary_op(other, and_id); }
+    GC_VALUE operator^(const GC_VALUE& other) const { return binary_op(other, xor_id); }
+    GC_VALUE operator|(const GC_VALUE& other) const { return binary_op(other, or_id); }
+    GC_VALUE operator<<(const GC_VALUE& other) const { return binary_op(other, lshift_id); }
+    GC_VALUE operator>>(const GC_VALUE& other) const { return binary_op(other, rshift_id); }
+  };
+
+  ID  GC_VALUE::hash_id = rb_intern("hash");
+  ID  GC_VALUE::lt_id = rb_intern("<");
+  ID  GC_VALUE::gt_id = rb_intern(">");
+  ID  GC_VALUE::eq_id = rb_intern("==");
+  ID  GC_VALUE::le_id = rb_intern("<=");
+  ID  GC_VALUE::ge_id = rb_intern(">=");
+
+  ID  GC_VALUE::pos_id = rb_intern("+@");
+  ID  GC_VALUE::neg_id = rb_intern("-@");
+  ID  GC_VALUE::inv_id = rb_intern("~");
+
+  ID  GC_VALUE::add_id = rb_intern("+");
+  ID  GC_VALUE::sub_id = rb_intern("-");
+  ID  GC_VALUE::mul_id = rb_intern("*");
+  ID  GC_VALUE::div_id = rb_intern("/");
+  ID  GC_VALUE::mod_id = rb_intern("%");
+
+  ID  GC_VALUE::and_id = rb_intern("&");
+  ID  GC_VALUE::or_id  = rb_intern("|");
+  ID  GC_VALUE::xor_id = rb_intern("^");
+
+  ID  GC_VALUE::lshift_id = rb_intern("<<");
+  ID  GC_VALUE::rshift_id = rb_intern(">>");
+
+  typedef GC_VALUE LANGUAGE_OBJ;
+
+} // namespace swig
+
+} // %fragment(GC_VALUE_definition)
+
+
+
+namespace swig {
+
+  %apply VALUE   {GC_VALUE};
+
+  // Make sure this is the last typecheck done
+  %typecheck(999999,fragment="GC_VALUE_definition",noblock=1) GC_VALUE, GC_VALUE&, 
+    const GC_VALUE& { $1 = 1; };
+
+  /* For input */
+  %typemap(in,fragment="GC_VALUE_definition",noblock=1) GC_VALUE* (GC_VALUE r), GC_VALUE& (GC_VALUE r)  {
+     r = $input; $1 = &r;
+   }
+
+  /* For output */
+  %typemap(out,fragment="GC_VALUE_definition",noblock=1)  GC_VALUE {
+    $result = (VALUE)$1;
+  }
+  
+  %typemap(out,fragment="GC_VALUE_definition",noblock=1)  GC_VALUE*, GC_VALUE const & {
+    $result = (VALUE)*$1;
+  }
+
+  %nodirector GC_VALUE;
+
+  // We ignore the constructor so that user can never create a GC_VALUE 
+  // manually
+  %ignore GC_VALUE::GC_VALUE;
+
+  struct GC_VALUE {
+    VALUE inspect() const;
+    VALUE to_s() const;
+    GC_VALUE();
+  protected:
+    GC_VALUE(const GC_VALUE&);
+    ~GC_VALUE();
+  };
+
+  %exception GC_VALUE {};
+
+
+  %ignore LANGUAGE_OBJ;
+  typedef GC_VALUE LANGUAGE_OBJ;
+}
+
+
+%init {
+  swig::SwigGCReferences::initialize();
+}
+
+
+
+//
+// Fragment that contains traits to properly deal with GC_VALUE.
+// These functions may be invoked as a need of the from(), asval(),
+// asptr() and as() template functors, usually used in %typemaps.
+//
+%fragment(SWIG_Traits_frag(swig::GC_VALUE),"header",fragment="StdTraits",fragment="GC_VALUE_definition") {
+namespace swig {
+  template <>  struct traits<GC_VALUE > {
+    typedef value_category category;
+    static const char* type_name() { return "GC_VALUE"; }
+  };
+  
+  template <>  struct traits_from<GC_VALUE> {
+    typedef GC_VALUE value_type;
+    static VALUE from(const value_type& val) {
+      return static_cast<VALUE>(val);
+    }
+  };
+  
+  template <> 
+  struct traits_check<GC_VALUE, value_category> {
+    static bool check(GC_VALUE) {
+      return true;
+    }
+  };
+  
+  template <>  struct traits_asval<GC_VALUE > {   
+    typedef GC_VALUE value_type;
+    static int asval(VALUE obj, value_type *val) {
+      if (val) *val = obj;
+      return SWIG_OK;
+    }
+  };
+} // swig
+} // %fragment(traits for swig::GC_VALUE)
+
+
+#endif  // __cplusplus
+
diff --git a/share/swig/2.0.11/ruby/rubycomplex.swg b/share/swig/3.0.12/ruby/rubycomplex.swg
index 4e249c7..4e249c7 100644
--- a/share/swig/2.0.11/ruby/rubycomplex.swg
+++ b/share/swig/3.0.12/ruby/rubycomplex.swg
diff --git a/share/swig/3.0.12/ruby/rubycontainer.swg b/share/swig/3.0.12/ruby/rubycontainer.swg
new file mode 100644
index 0000000..4f1c6f5
--- /dev/null
+++ b/share/swig/3.0.12/ruby/rubycontainer.swg
@@ -0,0 +1,1121 @@
+/* -----------------------------------------------------------------------------
+ * rubycontainer.swg
+ *
+ * Ruby sequence <-> C++ container wrapper
+ *
+ * This wrapper, and its iterator, allows a general use (and reuse) of
+ * the mapping between C++ and Ruby, thanks to the C++ templates.
+ *
+ * Of course, it needs the C++ compiler to support templates, but
+ * since we will use this wrapper with the STL containers, that should
+ * be the case.
+ * ----------------------------------------------------------------------------- */
+
+%{
+#include <iostream>
+%}
+
+
+#if !defined(SWIG_NO_EXPORT_ITERATOR_METHODS)
+# if !defined(SWIG_EXPORT_ITERATOR_METHODS)
+#  define SWIG_EXPORT_ITERATOR_METHODS SWIG_EXPORT_ITERATOR_METHODS
+# endif
+#endif
+
+%include <rubyiterators.swg>
+
+/**** The RubySequence C++ Wrap ***/
+
+%fragment("<stdexcept>");
+
+%include <std_except.i>
+
+
+%fragment("RubySequence_Base","header")
+{
+%#include <functional>
+
+
+namespace swig {
+  template < class T >
+  struct yield
+  {
+    bool
+    operator()( const T& v ) const
+    { 
+      return RTEST( rb_yield( swig::from< T >(v) ) );
+    }
+  };
+
+
+  inline size_t
+  check_index(ptrdiff_t i, size_t size, bool insert = false) {
+    if ( i < 0 ) {
+      if ((size_t) (-i) <= size)
+	return (size_t) (i + size);
+    } else if ( (size_t) i < size ) {
+      return (size_t) i;
+    } else if (insert && ((size_t) i == size)) {
+      return size;
+    }
+    
+    throw std::out_of_range("index out of range");
+  }
+
+  inline size_t
+  slice_index(ptrdiff_t i, size_t size) {
+    if ( i < 0 ) {
+      if ((size_t) (-i) <= size) {
+	return (size_t) (i + size);
+      } else {
+	throw std::out_of_range("index out of range");
+      }
+    } else {
+      return ( (size_t) i < size ) ? ((size_t) i) : size;
+    }
+  }
+
+  template <class Sequence, class Difference>
+  inline typename Sequence::iterator
+  getpos(Sequence* self, Difference i)  {
+    typename Sequence::iterator pos = self->begin();
+    std::advance(pos, check_index(i,self->size()));
+    return pos;
+  }
+
+  template <class Sequence, class Difference>
+  inline typename Sequence::const_iterator
+  cgetpos(const Sequence* self, Difference i)  {
+    typename Sequence::const_iterator pos = self->begin();
+    std::advance(pos, check_index(i,self->size()));
+    return pos;
+  }
+
+  template <class Sequence>
+  inline void
+  resize(Sequence *seq, typename Sequence::size_type n, typename Sequence::value_type x) {
+    seq->resize(n, x);
+  }
+
+  template <class Sequence, class Difference>
+  inline Sequence*
+  getslice(const Sequence* self, Difference i, Difference j) {
+    typename Sequence::size_type size = self->size();
+    typename Sequence::size_type ii = swig::check_index(i, size, (i == size && j == size));
+    typename Sequence::size_type jj = swig::slice_index(j, size);
+
+    if (jj > ii) {
+      typename Sequence::const_iterator vb = self->begin();
+      typename Sequence::const_iterator ve = self->begin();
+      std::advance(vb,ii);
+      std::advance(ve,jj);
+      return new Sequence(vb, ve);
+    } else {
+      return new Sequence();
+    }
+  }
+
+  template <class Sequence, class Difference, class InputSeq>
+  inline void
+  setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) {
+    typename Sequence::size_type size = self->size();
+    typename Sequence::size_type ii = swig::check_index(i, size, true);
+    typename Sequence::size_type jj = swig::slice_index(j, size);
+    if (jj < ii) jj = ii;
+    size_t ssize = jj - ii;
+    if (ssize <= v.size()) {
+      typename Sequence::iterator sb = self->begin();
+      typename InputSeq::const_iterator vmid = v.begin();
+      std::advance(sb,ii);
+      std::advance(vmid, jj - ii);
+      self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
+    } else {
+      typename Sequence::iterator sb = self->begin();
+      typename Sequence::iterator se = self->begin();
+      std::advance(sb,ii);
+      std::advance(se,jj);
+      self->erase(sb,se);
+      self->insert(sb, v.begin(), v.end());
+    }
+  }
+
+  template <class Sequence, class Difference>
+  inline void
+  delslice(Sequence* self, Difference i, Difference j) {
+    typename Sequence::size_type size = self->size();
+    typename Sequence::size_type ii = swig::check_index(i, size, true);
+    typename Sequence::size_type jj = swig::slice_index(j, size);
+    if (jj > ii) {
+      typename Sequence::iterator sb = self->begin();
+      typename Sequence::iterator se = self->begin();
+      std::advance(sb,ii);
+      std::advance(se,jj);
+      self->erase(sb,se);
+    }
+  }
+}
+}
+
+%fragment("RubySequence_Cont","header",
+	  fragment="<stddef.h>",
+	  fragment="StdTraits",
+	  fragment="RubySequence_Base",
+	  fragment="ConstIterator_T")
+{
+namespace swig
+{
+
+  /**
+   * This class is a proxy class for references, used to return and set values
+   * of an element of a Ruby Array of stuff.
+   * It can be used by RubySequence_InputIterator to make it work with STL
+   * algorithms.
+   */
+  template <class T>
+  struct RubySequence_Ref
+  {
+    RubySequence_Ref(VALUE  seq, int index)
+      : _seq(seq), _index(index)
+    {
+    }
+    
+    operator T () const
+    {
+      VALUE item = rb_ary_entry(_seq, _index );
+      try {
+	return swig::as<T>(item, true);
+      } catch (std::exception& e) {
+	char msg[1024];
+	sprintf(msg, "in sequence element %d ", _index);
+	VALUE lastErr = rb_gv_get("$!");
+	if ( lastErr == Qnil ) {
+	  %type_error(swig::type_name<T>());
+	}
+	VALUE str = rb_str_new2(msg);
+	str = rb_str_cat2( str, e.what() );
+	SWIG_Ruby_ExceptionType( NULL, str );
+	throw;
+      }
+    }
+
+    RubySequence_Ref& operator=(const T& v)
+    {
+      rb_ary_set(_seq, _index, swig::from< T >(v));
+      return *this;
+    }
+
+  private:
+    VALUE  _seq;
+    int _index;
+  };
+
+
+  /**
+   * This class is a proxy to return a pointer to a class, usually
+   * RubySequence_Ref. 
+   * It can be used by RubySequence_InputIterator to make it work with STL
+   * algorithms.
+   */
+  template <class T>
+  struct RubySequence_ArrowProxy
+  {
+    RubySequence_ArrowProxy(const T& x): m_value(x) {}
+    const T* operator->() const { return &m_value; }
+    operator const T*() const { return &m_value; }
+    T m_value;
+  };
+
+
+  /**
+   * Input Iterator.  This adapator class is a random access iterator that 
+   * allows you to use STL algorithms with a Ruby class (a Ruby Array by default).
+   */
+  template <class T, class Reference = RubySequence_Ref< T > >
+  struct RubySequence_InputIterator
+  {
+    typedef RubySequence_InputIterator<T, Reference > self;
+
+    typedef std::random_access_iterator_tag iterator_category;
+    typedef Reference reference;
+    typedef T value_type;
+    typedef T* pointer;
+    typedef ptrdiff_t difference_type;
+
+    RubySequence_InputIterator()
+    {
+    }
+
+    RubySequence_InputIterator(VALUE  seq, int index)
+      : _seq(seq), _index(index)
+    {
+    }
+
+    reference operator*() const
+    {
+      return reference(_seq, _index);
+    }
+
+    RubySequence_ArrowProxy<T>
+    operator->() const {
+      return RubySequence_ArrowProxy<T>(operator*());
+    }
+
+    bool operator==(const self& ri) const
+    {
+      return (_index == ri._index) && (_seq == ri._seq);
+    }
+
+    bool operator!=(const self& ri) const
+    {
+      return !(operator==(ri));
+    }
+
+    self& operator ++ ()
+    {
+      ++_index;
+      return *this;
+    }
+
+    self& operator -- ()
+    {
+      --_index;
+      return *this;
+    }
+
+    self& operator += (difference_type n)
+    {
+      _index += n;
+      return *this;
+    }
+
+    self operator +(difference_type n) const
+    {
+      return self(_seq, _index + n);
+    }
+
+    self& operator -= (difference_type n)
+    {
+      _index -= n;
+      return *this;
+    }
+
+    self operator -(difference_type n) const
+    {
+      return self(_seq, _index - n);
+    }
+
+    difference_type operator - (const self& ri) const
+    {
+      return _index - ri._index;
+    }
+
+    bool operator < (const self& ri) const
+    {
+      return _index < ri._index;
+    }
+
+    reference
+    operator[](difference_type n) const
+    {
+      return reference(_seq, _index + n);
+    }
+
+  private:
+    VALUE  _seq;
+    difference_type _index;
+  };
+
+
+  /**
+   * This adaptor class allows you to use a Ruby Array as if it was an STL
+   * container, giving it begin(), end(), and iterators.
+   */
+  template <class T>
+  struct RubySequence_Cont
+  {
+    typedef RubySequence_Ref<T> reference;
+    typedef const RubySequence_Ref<T> const_reference;
+    typedef T value_type;
+    typedef T* pointer;
+    typedef int difference_type;
+    typedef int size_type;
+    typedef const pointer const_pointer;
+    typedef RubySequence_InputIterator<T, reference> iterator;
+    typedef RubySequence_InputIterator<T, const_reference> const_iterator;
+
+    RubySequence_Cont(VALUE  seq) : _seq(0)
+    {
+      if (!rb_obj_is_kind_of(seq, rb_cArray)) {
+	throw std::invalid_argument("an Array is expected");
+      }
+      _seq = seq;
+    }
+
+    ~RubySequence_Cont()
+    {
+    }
+
+    size_type size() const
+    {
+      return RARRAY_LEN(_seq);
+    }
+
+    bool empty() const
+    {
+      return size() == 0;
+    }
+
+    iterator begin()
+    {
+      return iterator(_seq, 0);
+    }
+
+    const_iterator begin() const
+    {
+      return const_iterator(_seq, 0);
+    }
+
+    iterator end()
+    {
+      return iterator(_seq, size());
+    }
+
+    const_iterator end() const
+    {
+      return const_iterator(_seq, size());
+    }
+
+    reference operator[](difference_type n)
+    {
+      return reference(_seq, n);
+    }
+
+    const_reference operator[](difference_type n)  const
+    {
+      return const_reference(_seq, n);
+    }
+
+    bool check(bool set_err = false) const
+    {
+      int s = (int) size();
+      for (int i = 0; i < s; ++i) {
+	VALUE item = rb_ary_entry(_seq, i );
+	if (!swig::check<value_type>(item)) {
+	  if (set_err) {
+	    char msg[1024];
+	    sprintf(msg, "in sequence element %d", i);
+	    SWIG_Error(SWIG_RuntimeError, msg);
+	  }
+	  return false;
+	}
+      }
+      return true;
+    }
+
+  private:
+    VALUE  _seq;
+  };
+
+}
+}
+
+/** 
+ * Macros used to typemap an STL iterator -> SWIGIterator conversion.
+ */
+%define %swig_sequence_iterator(Sequence...)
+#if defined(SWIG_EXPORT_ITERATOR_METHODS)
+
+  %typemap(out,noblock=1,fragment="RubySequence_Cont")
+    const_iterator, const_reverse_iterator {
+    $result = SWIG_NewPointerObj(swig::make_const_iterator(%static_cast($1,const $type &),
+							   self),
+				 swig::ConstIterator::descriptor(),SWIG_POINTER_OWN);
+  }
+
+  %typemap(out,noblock=1,fragment="RubySequence_Cont")
+    iterator, reverse_iterator {
+    $result = SWIG_NewPointerObj(swig::make_nonconst_iterator(%static_cast($1,const $type &),
+							      self),
+				 swig::Iterator::descriptor(),SWIG_POINTER_OWN);
+  }
+
+  %typemap(out,noblock=1,fragment="RubySequence_Cont")
+    std::pair<const_iterator, const_iterator> {
+    $result = rb_ary_new2(2);
+    rb_ary_push($result, SWIG_NewPointerObj(swig::make_const_iterator(%static_cast($1,const $type &).first),
+					    swig::ConstIterator::descriptor(),SWIG_POINTER_OWN));
+    rb_ary_push($result, SWIG_NewPointerObj(swig::make_const_iterator(%static_cast($1,const $type &).second),
+					    swig::ConstIterator::descriptor(),SWIG_POINTER_OWN));
+  }
+
+  // std::map/multimap/set allow returning std::pair< iterator, iterator > from
+  // equal_range, but we cannot still modify the key, so the iterator is
+  // const.
+  %typemap(out,noblock=1,fragment="RubySequence_Cont")
+    std::pair<iterator, iterator> {
+    $result = rb_ary_new2(2);
+    rb_ary_push($result, SWIG_NewPointerObj(swig::make_const_iterator(%static_cast($1,const $type &).first),
+					    swig::ConstIterator::descriptor(),SWIG_POINTER_OWN));
+    rb_ary_push($result, SWIG_NewPointerObj(swig::make_const_iterator(%static_cast($1,const $type &).second),
+					    swig::ConstIterator::descriptor(),SWIG_POINTER_OWN));
+  }
+
+
+  %typemap(in,noblock=1,fragment="RubySequence_Cont")
+    const_iterator(swig::ConstIterator *iter = 0, int res),
+    const_reverse_iterator(swig::ConstIterator *iter = 0, int res) {
+    res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter), swig::ConstIterator::descriptor(), 0);
+    if (!SWIG_IsOK(res) || !iter) {
+      %argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
+    } else {
+      swig::ConstIterator_T<$type > *iter_t = dynamic_cast<swig::ConstIterator_T<$type > *>(iter);
+      if (iter_t) {
+	$1 = iter_t->get_current();
+      } else {
+	%argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
+      }
+    }
+  }
+
+  %typemap(in,noblock=1,fragment="RubySequence_Cont")
+    iterator(swig::Iterator *iter = 0, int res),
+    reverse_iterator(swig::Iterator *iter = 0, int res) {
+    res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter), swig::Iterator::descriptor(), 0);
+    if (!SWIG_IsOK(res) || !iter) {
+      %argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
+    } else {
+      swig::Iterator_T<$type > *iter_t = dynamic_cast<swig::Iterator_T<$type > *>(iter);
+      if (iter_t) {
+	$1 = iter_t->get_current();
+      } else {
+	%argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
+      }
+    }
+  }
+
+  %typecheck(%checkcode(ITERATOR),noblock=1,fragment="RubySequence_Cont")
+    const_iterator, const_reverse_iterator {
+    swig::ConstIterator *iter = 0;
+    int res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter), swig::ConstIterator::descriptor(), 0);
+    $1 = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::ConstIterator_T<$type > *>(iter) != 0));
+  }
+
+  %typecheck(%checkcode(ITERATOR),noblock=1,fragment="RubySequence_Cont")
+    iterator, reverse_iterator {
+    swig::ConstIterator *iter = 0;
+    int res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter), swig::Iterator::descriptor(), 0);
+    $1 = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::Iterator_T<$type > *>(iter) != 0));
+  }
+
+  %fragment("RubySequence_Cont");
+
+//   %newobject iterator;
+//   %newobject const_iterator;
+//   %extend  {
+//     swig::Iterator* iterator(VALUE* RUBY_SELF) {
+//       return swig::make_nonconst_iterator($self->begin(), $self->begin(), 
+// 				             $self->end(), *RUBY_SELF);
+//     }
+
+//     swig::ConstIterator* const_iterator(VALUE* RUBY_SELF) {
+//       return swig::make_const_iterator($self->begin(), $self->begin(), 
+// 					$self->end(), *RUBY_SELF);
+//     }
+//   }
+#endif //SWIG_EXPORT_ITERATOR_METHODS
+%enddef
+
+
+/**** The Ruby container methods  ****/
+
+
+
+%define %swig_container_methods(Container...)
+
+  %extend {
+
+  %newobject dup;
+  Container* dup()
+    {
+      return new Container(*$self);
+    }
+
+  }
+
+%enddef
+
+
+/**
+ * Macro used to define common Ruby printing methods for STL container
+ */
+%define %swig_sequence_printing_methods(Sequence...)
+
+  %extend {
+
+  VALUE inspect()
+    {
+      Sequence::const_iterator i = $self->begin();
+      Sequence::const_iterator e = $self->end();
+      const char *type_name = swig::type_name< Sequence >();
+      VALUE str = rb_str_new2(type_name);
+      str = rb_str_cat2( str, " [" );
+      bool comma = false;
+      VALUE tmp;
+      for ( ; i != e; ++i, comma = true )
+	{
+	  if (comma) str = rb_str_cat2( str, "," );
+	  tmp = swig::from< Sequence::value_type >( *i );
+	  tmp = rb_inspect( tmp );
+	  str = rb_str_buf_append( str, tmp );
+	}
+      str = rb_str_cat2( str, "]" );
+      return str;
+    }
+
+  VALUE to_a()
+    {
+      Sequence::const_iterator i = $self->begin();
+      Sequence::const_iterator e = $self->end();
+      VALUE ary = rb_ary_new2( std::distance( i, e ) );
+      VALUE tmp;
+      for ( ; i != e; ++i )
+	{
+	  tmp = swig::from< Sequence::value_type >( *i );
+	  rb_ary_push( ary, tmp );
+	}
+      return ary;
+    }
+
+  VALUE to_s()
+    {
+      Sequence::iterator i = $self->begin();
+      Sequence::iterator e = $self->end();
+      VALUE str = rb_str_new2( "" );
+      VALUE tmp;
+      for ( ; i != e; ++i )
+	{
+	  tmp = swig::from< Sequence::value_type >( *i );
+	  tmp = rb_obj_as_string( tmp );
+	  str = rb_str_buf_append( str, tmp );
+	}
+      return str;
+    }
+}
+%enddef
+
+
+/**
+ * Macro used to add common methods to all STL sequence-type containers 
+ */
+%define %swig_sequence_methods_non_resizable_common(Sequence...)
+  %swig_container_methods(%arg(Sequence))
+  %swig_sequence_iterator(%arg(Sequence))
+  %swig_sequence_printing_methods(%arg(Sequence))
+
+  %fragment("RubySequence_Base");
+
+  %extend {
+
+  VALUE slice( difference_type i, difference_type length ) throw (std::invalid_argument) {
+      if ( length < 0 )
+        return Qnil;
+      std::size_t len = $self->size();
+      if ( i < 0 ) {
+        if ( i + static_cast<Sequence::difference_type>(len) < 0 )
+          return Qnil;
+        else
+          i = len + i;
+      }
+      Sequence::difference_type j = length + i;
+      if ( j > static_cast<Sequence::difference_type>(len) )
+        j = len;
+
+      VALUE r = Qnil;
+      try {
+	r = swig::from< const Sequence* >( swig::getslice(self, i, j) );
+      }
+      catch( std::out_of_range ) {
+      }
+      return r;
+    }
+
+
+    Sequence* each()
+      {
+	if ( !rb_block_given_p() )
+	  rb_raise( rb_eArgError, "no block given");
+
+	VALUE r;
+	Sequence::const_iterator i = self->begin();
+	Sequence::const_iterator e = self->end();
+	for ( ; i != e; ++i )
+	  {
+	    r = swig::from< Sequence::value_type >(*i);
+	    rb_yield(r);
+	  }
+	
+	return self;
+      }
+
+    VALUE __delete2__(const value_type& i) {
+      VALUE r = Qnil;
+      return r;
+    }
+
+  }
+%enddef
+
+%define %swig_sequence_methods_resizable_common(Sequence...)
+  %extend {
+
+    %newobject select;
+    Sequence* select() {
+      if ( !rb_block_given_p() )
+	rb_raise( rb_eArgError, "no block given" );
+
+      Sequence* r = new Sequence();
+      Sequence::const_iterator i = $self->begin();
+      Sequence::const_iterator e = $self->end();
+      for ( ; i != e; ++i )
+	{
+	  VALUE v = swig::from< Sequence::value_type >(*i);
+	  if ( RTEST( rb_yield(v) ) )
+	    $self->insert( r->end(), *i);
+	}
+	
+      return r;
+    }
+
+    VALUE delete_at(difference_type i) {
+      VALUE r = Qnil;
+      try {
+	Sequence::iterator at = swig::getpos(self, i);
+	r = swig::from< Sequence::value_type >( *(at) );
+	$self->erase(at); 
+      }
+      catch (std::out_of_range)
+	{
+	}
+      return r;
+    }
+  }
+%enddef
+
+%define %swig_sequence_methods_common(Sequence...)
+  %swig_sequence_methods_non_resizable_common(%arg(Sequence))
+  %swig_sequence_methods_resizable_common(%arg(Sequence))
+%enddef
+
+/**
+ * Macro used to add functions for back insertion of values in
+ * STL sequence containers
+ */
+%define %swig_sequence_back_inserters( Sequence... )
+  %extend {
+
+    VALUE pop() {
+      if ($self->empty()) return Qnil;
+      Sequence::value_type x = self->back();
+      $self->pop_back();
+      return swig::from< Sequence::value_type >( x );
+    }
+
+    %alias push "<<";
+    const value_type push( const value_type& e ) {
+      $self->push_back( e );
+      return e;
+    }
+
+    %newobject reject;
+    Sequence* reject() {
+      if ( !rb_block_given_p() )
+	rb_raise( rb_eArgError, "no block given" );
+
+      Sequence* r = new Sequence();
+      std::remove_copy_if( $self->begin(), $self->end(),              
+			   std::back_inserter(*r),
+			   swig::yield< Sequence::value_type >() );
+      return r;
+    }
+
+  }
+%enddef
+
+%define %swig_sequence_methods_extra(Sequence...)
+  %extend {
+    %alias reject_bang "delete_if";
+    Sequence* reject_bang() {
+      if ( !rb_block_given_p() )
+	rb_raise( rb_eArgError, "no block given" );
+
+      $self->erase( std::remove_if( $self->begin(), $self->end(),
+            swig::yield< Sequence::value_type >() ), $self->end() );
+      return $self;
+    }
+  }
+%enddef
+
+%define %swig_sequence_methods_non_resizable_accessors(Sequence...)
+  %extend {
+
+    VALUE at(difference_type i) const {
+      VALUE r = Qnil;
+      try {
+	r = swig::from< Sequence::value_type >( *(swig::cgetpos(self, i)) );
+      }
+      catch( std::out_of_range ) {
+      }
+      return r;
+    }
+
+    VALUE __getitem__(difference_type i, difference_type length) const throw (std::invalid_argument) {
+      if ( length < 0 )
+        return Qnil;
+      std::size_t len = $self->size();
+      if ( i < 0 ) {
+        if ( i + static_cast<Sequence::difference_type>(len) < 0 )
+          return Qnil;
+        else
+          i = len + i;
+      }
+      Sequence::difference_type j = length + i;
+      if ( j > static_cast<Sequence::difference_type>(len) )
+        j = len;
+
+      VALUE r = Qnil;
+      try {
+	r = swig::from< const Sequence* >( swig::getslice(self, i, j) );
+      }
+      catch( std::out_of_range ) {
+      }
+      return r;
+    }
+
+    VALUE __getitem__(difference_type i) const {
+      VALUE r = Qnil;
+      try {
+	r = swig::from< Sequence::value_type >( *(swig::cgetpos(self, i)) );
+      }
+      catch( std::out_of_range ) {
+      }
+      return r;
+    }
+
+    VALUE __getitem__(VALUE i) const throw (std::invalid_argument) {
+      if ( rb_obj_is_kind_of( i, rb_cRange ) == Qfalse ) {
+        rb_raise( rb_eTypeError, "not a valid index or range" );
+      }
+
+      static ID id_end   = rb_intern("end");
+      static ID id_start = rb_intern("begin");
+      static ID id_noend = rb_intern("exclude_end?");
+
+      VALUE start = rb_funcall( i, id_start, 0 );
+      VALUE end   = rb_funcall( i, id_end, 0 );
+      bool  noend = ( rb_funcall( i, id_noend, 0 ) == Qtrue );
+
+      int len = $self->size();
+
+      int s = NUM2INT( start );
+      if ( s < 0 ) {
+        s = len + s;
+        if ( s < 0 )
+          return Qnil;
+      } else if ( s > len )
+        return Qnil;
+
+      int e = NUM2INT( end );
+      if ( e < 0 ) e = len + e;
+      if ( noend ) e -= 1;
+      if ( e < 0 ) e = -1;
+      if ( e >= len ) e = len - 1;
+      if ( s == len ) e = len - 1;
+
+      return swig::from< Sequence* >( swig::getslice(self, s, e+1) );
+    }
+
+    VALUE __setitem__(difference_type i, const value_type& x) throw (std::invalid_argument, std::out_of_range)
+      {
+	if ( i >= static_cast<Sequence::difference_type>( $self->size()) )
+          swig::resize( $self, i+1, x );
+        else
+          *(swig::getpos($self, i)) = x;
+
+	return swig::from< Sequence::value_type >( x );
+      }
+
+    VALUE __setitem__(difference_type i, difference_type length, const Sequence& v) throw (std::invalid_argument) {
+
+      if ( length < 0 )
+        return Qnil;
+      std::size_t len = $self->size();
+      if ( i < 0 ) {
+        if ( i + static_cast<Sequence::difference_type>(len) < 0 )
+          return Qnil;
+        else
+          i = len + i;
+      }
+      Sequence::difference_type j = length + i;
+      if ( j > static_cast<Sequence::difference_type>(len) ) {
+        swig::resize( $self, j, *(v.begin()) );
+      }
+
+      VALUE r = Qnil;
+      swig::setslice($self, i, j, v);
+      r = swig::from< const Sequence* >( &v );
+      return r;
+    }
+ }
+%enddef
+
+/**
+ * Macro used to add functions for non resizable sequences
+ */
+%define %swig_sequence_methods_non_resizable(Sequence...)
+  %swig_sequence_methods_non_resizable_common(%arg(Sequence))
+  %swig_sequence_methods_non_resizable_accessors(%arg(Sequence))
+%enddef
+
+
+/**
+ * Macro used to add functions for sequences
+ */
+%define %swig_sequence_methods(Sequence...)
+  %swig_sequence_methods_non_resizable_common(%arg(Sequence))
+  %swig_sequence_methods_resizable_common(%arg(Sequence))
+  %swig_sequence_methods_non_resizable_accessors(%arg(Sequence))
+  %swig_sequence_methods_extra(%arg(Sequence));
+  %swig_sequence_back_inserters(%arg(Sequence));
+%enddef
+
+%define %swig_sequence_methods_non_resizable_val(Sequence...)
+  %swig_sequence_methods_non_resizable(%arg(Sequence))
+%enddef
+
+%define %swig_sequence_methods_val(Sequence...)
+  %swig_sequence_methods(%arg(Sequence))
+%enddef
+
+
+/**
+ * Macro used to add functions for front insertion of
+ * elements in STL sequence containers that support it.
+ */
+%define %swig_sequence_front_inserters( Sequence... )
+%extend {
+
+  VALUE shift()
+    {
+      if ($self->empty()) return Qnil;
+      Sequence::value_type x = self->front();
+      $self->erase( $self->begin() );
+      return swig::from< Sequence::value_type >( x );
+    }
+
+  %typemap(in) (int argc, VALUE* argv) {
+    $1 = argc - 1;
+    $2 = argv + 1;
+  }
+
+  Sequence* insert( difference_type pos, int argc, VALUE* argv, ... )
+    {
+      std::size_t len = $self->size();
+      std::size_t   i = swig::check_index( pos, len, true );
+      Sequence::iterator start;
+
+      VALUE elem = argv[0];
+      int idx = 0;
+      try {
+	Sequence::value_type val = swig::as<Sequence::value_type>( elem, true );
+	if ( i >= len ) {
+	  $self->resize(i-1, val);
+	  return $self;
+	}
+	start = $self->begin();
+	std::advance( start, i );
+	$self->insert( start++, val );
+
+	for ( ++idx; idx < argc; ++idx )
+	  {
+	    elem = argv[idx];
+	    val = swig::as<Sequence::value_type>( elem );
+	    $self->insert( start++, val );
+	  }
+
+      } 
+      catch( std::invalid_argument )
+	{
+	  rb_raise( rb_eArgError, "%s",
+		    Ruby_Format_TypeError( "", 
+					   swig::type_name<Sequence::value_type>(),
+					   __FUNCTION__, idx+2, elem ));
+	}
+
+
+      return $self;
+    }
+
+  %typemap(in) (int argc, VALUE* argv) {
+    $1 = argc;
+    $2 = argv;
+  }
+
+  Sequence* unshift( int argc, VALUE* argv, ... )
+    {
+      for ( int idx = argc-1; idx >= 0; --idx )
+	{
+	  Sequence::iterator start = $self->begin();
+	  VALUE elem = argv[idx];
+	  try {
+	    Sequence::value_type val = swig::as<Sequence::value_type>( elem, true );
+	    $self->insert( start, val );
+	  }
+	  catch( std::invalid_argument )
+	    {
+	      rb_raise( rb_eArgError, "%s",
+			Ruby_Format_TypeError( "", 
+					       swig::type_name<Sequence::value_type>(),
+					       __FUNCTION__, idx+2, elem ));
+	    }
+	}
+
+      return $self;
+    }
+}
+%enddef
+
+
+//
+// Common fragments
+//
+
+%fragment("StdSequenceTraits","header",
+	  fragment="StdTraits",
+	  fragment="RubySequence_Cont",
+	  fragment="GC_VALUE_definition")
+{
+namespace swig {
+  template <class RubySeq, class Seq>
+  inline void
+  assign(const RubySeq& rubyseq, Seq* seq) {
+    // seq->assign(rubyseq.begin(), rubyseq.end()); // not used as not always implemented
+    typedef typename RubySeq::value_type value_type;
+    typename RubySeq::const_iterator it = rubyseq.begin();
+    for (;it != rubyseq.end(); ++it) {
+      seq->insert(seq->end(),(value_type)(*it));
+    }
+  }
+
+  template <class Seq, class T = typename Seq::value_type >
+  struct traits_asptr_stdseq {
+    typedef Seq sequence;
+    typedef T value_type;
+
+    static int asptr(VALUE obj, sequence **seq) {
+      if (rb_obj_is_kind_of(obj, rb_cArray) == Qtrue) {
+	try {
+	  RubySequence_Cont<value_type> rubyseq(obj);
+	  if (seq) {
+	    sequence *pseq = new sequence();
+	    assign(rubyseq, pseq);
+	    *seq = pseq;
+	    return SWIG_NEWOBJ;
+	  } else {
+	    return rubyseq.check() ? SWIG_OK : SWIG_ERROR;
+	  }
+	} catch (std::exception& e) {
+	  if (seq) {
+	    VALUE lastErr = rb_gv_get("$!");
+	    if (lastErr == Qnil) {
+	      rb_raise(rb_eTypeError, "%s", e.what());
+	    }
+	  }
+	  return SWIG_ERROR;
+	}
+      } else {
+	sequence *p;
+	swig_type_info *descriptor = swig::type_info<sequence>();
+	if (descriptor && SWIG_IsOK(SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0))) {
+	  if (seq) *seq = p;
+	  return SWIG_OLDOBJ;
+	}
+      }
+      return SWIG_ERROR;
+    }
+  };
+
+  // Partial specialization for GC_VALUE's.  No need to typecheck each
+  // element.
+  template< class Seq >
+  struct traits_asptr_stdseq< Seq, swig::GC_VALUE > {
+    typedef Seq sequence;
+    typedef swig::GC_VALUE value_type;
+
+    static int asptr(VALUE obj, sequence **seq) {
+      if (rb_obj_is_kind_of(obj, rb_cArray) == Qtrue) {
+	try {
+	  if (seq) {
+	    RubySequence_Cont<value_type> rubyseq(obj);
+	    sequence *pseq = new sequence();
+	    assign(rubyseq, pseq);
+	    *seq = pseq;
+	    return SWIG_NEWOBJ;
+	  } else {
+	    return true;
+	  }
+	} catch (std::exception& e) {
+	  if (seq) {
+	    VALUE lastErr = rb_gv_get("$!");
+	    if (lastErr == Qnil) {
+	      rb_raise(rb_eTypeError, "%s", e.what());
+	    }
+	  }
+	  return SWIG_ERROR;
+	}
+      } else {
+	sequence *p;
+	swig_type_info *descriptor = swig::type_info<sequence>();
+	if (descriptor && SWIG_IsOK(SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0))) {
+	  if (seq) *seq = p;
+	  return SWIG_OLDOBJ;
+	}
+      }
+      return SWIG_ERROR;
+    }
+  };
+
+  template <class Seq, class T = typename Seq::value_type >
+  struct traits_from_stdseq {
+    typedef Seq sequence;
+    typedef T value_type;
+    typedef typename Seq::size_type size_type;
+    typedef typename sequence::const_iterator const_iterator;
+
+    static VALUE from(const sequence& seq) {
+#ifdef SWIG_RUBY_EXTRA_NATIVE_CONTAINERS
+      swig_type_info *desc = swig::type_info<sequence>();
+      if (desc && desc->clientdata) {
+	return SWIG_NewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
+      }
+#endif
+      size_type size = seq.size();
+      if (size <= (size_type)INT_MAX) {
+	VALUE obj = rb_ary_new2((int)size);
+	int i = 0;
+	for (const_iterator it = seq.begin();
+	     it != seq.end(); ++it, ++i) {
+	  rb_ary_push(obj, swig::from< value_type >(*it));
+	}
+	rb_obj_freeze(obj);  // treat as immutable result
+	return obj;
+      } else {
+	rb_raise(rb_eRangeError,"sequence size not valid in ruby");
+	return Qnil;
+      }
+    }
+  };
+}
+}
+
+
+%include <rubycontainer_extended.swg>
diff --git a/share/swig/2.0.11/ruby/rubycontainer_extended.swg b/share/swig/3.0.12/ruby/rubycontainer_extended.swg
index 7514ba2..7514ba2 100644
--- a/share/swig/2.0.11/ruby/rubycontainer_extended.swg
+++ b/share/swig/3.0.12/ruby/rubycontainer_extended.swg
diff --git a/share/swig/2.0.11/ruby/rubydef.swg b/share/swig/3.0.12/ruby/rubydef.swg
index 956aaee..956aaee 100644
--- a/share/swig/2.0.11/ruby/rubydef.swg
+++ b/share/swig/3.0.12/ruby/rubydef.swg
diff --git a/share/swig/2.0.11/ruby/rubyerrors.swg b/share/swig/3.0.12/ruby/rubyerrors.swg
index 434544b..434544b 100644
--- a/share/swig/2.0.11/ruby/rubyerrors.swg
+++ b/share/swig/3.0.12/ruby/rubyerrors.swg
diff --git a/share/swig/2.0.11/ruby/rubyfragments.swg b/share/swig/3.0.12/ruby/rubyfragments.swg
index 3c3b658..3c3b658 100644
--- a/share/swig/2.0.11/ruby/rubyfragments.swg
+++ b/share/swig/3.0.12/ruby/rubyfragments.swg
diff --git a/share/swig/2.0.11/ruby/rubyhead.swg b/share/swig/3.0.12/ruby/rubyhead.swg
index 9960087..9960087 100644
--- a/share/swig/2.0.11/ruby/rubyhead.swg
+++ b/share/swig/3.0.12/ruby/rubyhead.swg
diff --git a/share/swig/2.0.11/ruby/rubyinit.swg b/share/swig/3.0.12/ruby/rubyinit.swg
index fc6e039..fc6e039 100644
--- a/share/swig/2.0.11/ruby/rubyinit.swg
+++ b/share/swig/3.0.12/ruby/rubyinit.swg
diff --git a/share/swig/2.0.11/ruby/rubyiterators.swg b/share/swig/3.0.12/ruby/rubyiterators.swg
index 88f1e7c..88f1e7c 100644
--- a/share/swig/2.0.11/ruby/rubyiterators.swg
+++ b/share/swig/3.0.12/ruby/rubyiterators.swg
diff --git a/share/swig/2.0.11/ruby/rubykw.swg b/share/swig/3.0.12/ruby/rubykw.swg
index 194687b..194687b 100644
--- a/share/swig/2.0.11/ruby/rubykw.swg
+++ b/share/swig/3.0.12/ruby/rubykw.swg
diff --git a/share/swig/2.0.11/ruby/rubymacros.swg b/share/swig/3.0.12/ruby/rubymacros.swg
index de2a52b..de2a52b 100644
--- a/share/swig/2.0.11/ruby/rubymacros.swg
+++ b/share/swig/3.0.12/ruby/rubymacros.swg
diff --git a/share/swig/2.0.11/ruby/rubyopers.swg b/share/swig/3.0.12/ruby/rubyopers.swg
index d1ac8bf..d1ac8bf 100644
--- a/share/swig/2.0.11/ruby/rubyopers.swg
+++ b/share/swig/3.0.12/ruby/rubyopers.swg
diff --git a/share/swig/3.0.12/ruby/rubyprimtypes.swg b/share/swig/3.0.12/ruby/rubyprimtypes.swg
new file mode 100644
index 0000000..3a84819
--- /dev/null
+++ b/share/swig/3.0.12/ruby/rubyprimtypes.swg
@@ -0,0 +1,227 @@
+/* -----------------------------------------------------------------------------
+ * rubyprimtypes.swg
+ * ----------------------------------------------------------------------------- */
+/* ------------------------------------------------------------
+ * Primitive Types
+ * ------------------------------------------------------------ */
+
+/* auxiliary ruby fail method */
+
+%fragment("SWIG_ruby_failed","header")
+{
+SWIGINTERN VALUE
+SWIG_ruby_failed(void)
+{
+  return Qnil;
+} 
+}
+
+%define %ruby_aux_method(Type, Method, Action)
+SWIGINTERN VALUE SWIG_AUX_##Method##(VALUE *args)
+{
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  Type *res = (Type *)(args[1]);
+  *res = Action;
+  return obj;
+}
+%enddef
+
+
+/* boolean */
+
+%fragment(SWIG_From_frag(bool),"header") {
+SWIGINTERNINLINE VALUE
+SWIG_From_dec(bool)(bool value)
+{
+  return value ? Qtrue : Qfalse;
+}
+}
+
+%fragment(SWIG_AsVal_frag(bool),"header",
+	  fragment=SWIG_AsVal_frag(int)) {
+SWIGINTERN int
+SWIG_AsVal_dec(bool)(VALUE obj, bool *val)
+{
+  if (obj == Qtrue) {
+    if (val) *val = true;
+    return SWIG_OK;
+  } else if (obj == Qfalse) {
+    if (val) *val = false;
+    return SWIG_OK;
+  } else {
+    int res = 0;
+    if (SWIG_AsVal(int)(obj, &res) == SWIG_OK) {    
+      if (val) *val = res ? true : false;
+      return SWIG_OK;
+    }
+  }  
+  return SWIG_TypeError;
+}
+}
+
+/* long */
+
+%fragment(SWIG_From_frag(long),"header",
+	  fragment="<limits.h>") {
+  %define_as(SWIG_From_dec(long),           LONG2NUM)
+}
+
+%fragment(SWIG_AsVal_frag(long),"header",fragment="SWIG_ruby_failed") {
+%ruby_aux_method(long, NUM2LONG, type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj))
+
+SWIGINTERN int
+SWIG_AsVal_dec(long)(VALUE obj, long* val)
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
+    long v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+}
+
+/* unsigned long */
+
+%fragment(SWIG_From_frag(unsigned long),"header",
+	  fragment=SWIG_From_frag(long)) {
+SWIGINTERNINLINE VALUE
+SWIG_From_dec(unsigned long)(unsigned long value)
+{
+  return ULONG2NUM(value); 
+}
+}
+
+%fragment(SWIG_AsVal_frag(unsigned long),"header",fragment="SWIG_ruby_failed") {
+%ruby_aux_method(unsigned long, NUM2ULONG, type == T_FIXNUM ? NUM2ULONG(obj) : rb_big2ulong(obj))
+
+SWIGINTERN int
+SWIG_AsVal_dec(unsigned long)(VALUE obj, unsigned long *val) 
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
+    unsigned long v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+}
+
+/* long long */
+
+%fragment(SWIG_From_frag(long long),"header",
+	  fragment=SWIG_From_frag(long),
+	  fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERNINLINE VALUE 
+SWIG_From_dec(long long)(long long value)
+{
+  return LL2NUM(value);
+}
+%#endif
+}
+
+%fragment(SWIG_AsVal_frag(long long),"header",
+	  fragment="SWIG_ruby_failed",
+	  fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+%ruby_aux_method(long long, NUM2LL, type == T_FIXNUM ? NUM2LL(obj) : rb_big2ll(obj))
+
+SWIGINTERN int
+SWIG_AsVal_dec(long long)(VALUE obj, long long *val)
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
+    long long v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+%#endif
+}
+
+/* unsigned long long */
+
+%fragment(SWIG_From_frag(unsigned long long),"header",
+	  fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERNINLINE VALUE 
+SWIG_From_dec(unsigned long long)(unsigned long long value)
+{
+  return ULL2NUM(value);
+}
+%#endif
+}
+
+%fragment(SWIG_AsVal_frag(unsigned long long),"header",
+	  fragment="SWIG_ruby_failed",
+	  fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+%ruby_aux_method(long long, NUM2ULL,  type == T_FIXNUM ? NUM2ULL(obj) : rb_big2ull(obj))
+
+SWIGINTERN int
+SWIG_AsVal_dec(unsigned long long)(VALUE obj, unsigned long long *val)
+{ 
+  VALUE type = TYPE(obj);
+  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
+    unsigned long long v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+%#endif
+}
+
+/* double */
+
+%fragment(SWIG_From_frag(double),"header") {
+  %define_as(SWIG_From_dec(double),  rb_float_new)
+}
+
+%fragment(SWIG_AsVal_frag(double),"header",fragment="SWIG_ruby_failed") {
+%ruby_aux_method(double, NUM2DBL, NUM2DBL(obj); (void)type)
+
+SWIGINTERN int
+SWIG_AsVal_dec(double)(VALUE obj, double *val)
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FLOAT) || (type == T_FIXNUM) || (type == T_BIGNUM)) {
+    double v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2DBL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+}
+
+
diff --git a/share/swig/3.0.12/ruby/rubyrun.swg b/share/swig/3.0.12/ruby/rubyrun.swg
new file mode 100644
index 0000000..249494a
--- /dev/null
+++ b/share/swig/3.0.12/ruby/rubyrun.swg
@@ -0,0 +1,455 @@
+/* -----------------------------------------------------------------------------
+ * rubyrun.swg
+ *
+ * This file contains the runtime support for Ruby modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
+#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
+#define swig_owntype                                    swig_ruby_owntype
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) 		SWIG_Ruby_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
+#define SWIG_Error(code, msg)            		rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
+#define SWIG_fail                        		goto fail				 
+
+
+/* Ruby-specific SWIG API */
+
+#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
+#define SWIG_define_class(ty)                        	SWIG_Ruby_define_class(ty)
+#define SWIG_NewClassInstance(value, ty)             	SWIG_Ruby_NewClassInstance(value, ty)
+#define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
+#define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  
+
+#include "assert.h"
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  VALUE klass;
+  VALUE mImpl;
+  void  (*mark)(void *);
+  void  (*destroy)(void *);
+  int trackObjects;
+} swig_class;
+
+
+/* Global pointer used to keep some internal SWIG stuff */
+static VALUE _cSWIG_Pointer = Qnil;
+static VALUE swig_runtime_data_type_pointer = Qnil;
+
+/* Global IDs used to keep some internal SWIG stuff */
+static ID swig_arity_id = 0;
+static ID swig_call_id  = 0;
+
+/*
+  If your swig extension is to be run within an embedded ruby and has
+  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
+  This will reset ruby's stack frame on each entry point from the main 
+  program the first time a virtual director function is invoked (in a 
+  non-recursive way).
+  If this is not done, you run the risk of Ruby trashing the stack.
+*/
+
+#ifdef RUBY_EMBEDDED
+
+#  define SWIG_INIT_STACK                            \
+      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
+      ++swig_virtual_calls;
+#  define SWIG_RELEASE_STACK --swig_virtual_calls;
+#  define Ruby_DirectorTypeMismatchException(x) \
+          rb_raise( rb_eTypeError, "%s", x ); return c_result;
+
+      static unsigned int swig_virtual_calls = 0;
+
+#else  /* normal non-embedded extension */
+
+#  define SWIG_INIT_STACK
+#  define SWIG_RELEASE_STACK
+#  define Ruby_DirectorTypeMismatchException(x) \
+          throw Swig::DirectorTypeMismatchException( x );
+
+#endif  /* RUBY_EMBEDDED */
+
+
+SWIGRUNTIME VALUE 
+getExceptionClass(void) {
+  static int init = 0;
+  static VALUE rubyExceptionClass ;
+  if (!init) {
+    init = 1;
+    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
+  }
+  return rubyExceptionClass;
+} 
+
+/* This code checks to see if the Ruby object being raised as part
+   of an exception inherits from the Ruby class Exception.  If so,
+   the object is simply returned.  If not, then a new Ruby exception
+   object is created and that will be returned to Ruby.*/
+SWIGRUNTIME VALUE
+SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
+  VALUE exceptionClass = getExceptionClass();
+  if (rb_obj_is_kind_of(obj, exceptionClass)) {
+    return obj;
+  }  else {
+    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
+  }
+}
+
+/* Initialize Ruby runtime support */
+SWIGRUNTIME void
+SWIG_Ruby_InitRuntime(void)
+{
+  if (_mSWIG == Qnil) {
+    _mSWIG = rb_define_module("SWIG");
+    swig_call_id  = rb_intern("call");
+    swig_arity_id = rb_intern("arity");
+  }
+}
+
+/* Define Ruby class for C type */
+SWIGRUNTIME void
+SWIG_Ruby_define_class(swig_type_info *type)
+{
+  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+  sprintf(klass_name, "TYPE%s", type->name);
+  if (NIL_P(_cSWIG_Pointer)) {
+    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
+    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
+  }
+  rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
+  free((void *) klass_name);
+}
+
+/* Create a new pointer object */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
+{
+  int own =  flags & SWIG_POINTER_OWN; 
+  int track;
+  char *klass_name;
+  swig_class *sklass;
+  VALUE klass;
+  VALUE obj;
+  
+  if (!ptr)
+    return Qnil;
+  
+  if (type->clientdata) {
+    sklass = (swig_class *) type->clientdata;
+		
+    /* Are we tracking this class and have we already returned this Ruby object? */
+    track = sklass->trackObjects;
+    if (track) {
+      obj = SWIG_RubyInstanceFor(ptr);
+      
+      /* Check the object's type and make sure it has the correct type.
+        It might not in cases where methods do things like 
+        downcast methods. */
+      if (obj != Qnil) {
+        VALUE value = rb_iv_get(obj, "@__swigtype__");
+        const char* type_name = RSTRING_PTR(value);
+				
+        if (strcmp(type->name, type_name) == 0) {
+          return obj;
+        }
+      }
+    }
+
+    /* Create a new Ruby object */
+    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
+			   ( own ? VOIDFUNC(sklass->destroy) : 
+			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
+			     ), ptr);
+
+    /* If tracking is on for this class then track this object. */
+    if (track) {
+      SWIG_RubyAddTracking(ptr, obj);
+    }
+  } else {
+    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+    sprintf(klass_name, "TYPE%s", type->name);
+    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
+    free((void *) klass_name);
+    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
+  }
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  
+  return obj;
+}
+
+/* Create a new class instance (always owned) */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
+{
+  VALUE obj;
+  swig_class *sklass = (swig_class *) type->clientdata;
+  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  return obj;
+}
+
+/* Get type mangle from class name */
+SWIGRUNTIMEINLINE char *
+SWIG_Ruby_MangleStr(VALUE obj)
+{
+  VALUE stype = rb_iv_get(obj, "@__swigtype__");
+  return StringValuePtr(stype);
+}
+
+/* Acquire a pointer value */
+typedef struct {
+  void (*datafree)(void *);
+  int own;
+} swig_ruby_owntype;
+
+SWIGRUNTIME swig_ruby_owntype
+SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
+  swig_ruby_owntype oldown = {0, 0};
+  if (obj) {
+    oldown.datafree = RDATA(obj)->dfree;
+    RDATA(obj)->dfree = own.datafree;
+  }
+  return oldown;
+}
+
+/* Convert a pointer value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
+{
+  char *c;
+  swig_cast_info *tc;
+  void *vptr = 0;
+
+  /* Grab the pointer */
+  if (NIL_P(obj)) {
+    if (ptr)
+      *ptr = 0;
+    return SWIG_OK;
+  } else {
+    if (TYPE(obj) != T_DATA) {
+      return SWIG_ERROR;
+    }
+    Data_Get_Struct(obj, void, vptr);
+  }
+  
+  if (own) {
+    own->datafree = RDATA(obj)->dfree;
+    own->own = 0;
+  }
+    
+  /* Check to see if the input object is giving up ownership
+     of the underlying C struct or C++ object.  If so then we
+     need to reset the destructor since the Ruby object no 
+     longer owns the underlying C++ object.*/ 
+  if (flags & SWIG_POINTER_DISOWN) {
+    /* Is tracking on for this class? */
+    int track = 0;
+    if (ty && ty->clientdata) {
+      swig_class *sklass = (swig_class *) ty->clientdata;
+      track = sklass->trackObjects;
+    }
+		
+    if (track) {
+      /* We are tracking objects for this class.  Thus we change the destructor
+       * to SWIG_RubyRemoveTracking.  This allows us to
+       * remove the mapping from the C++ to Ruby object
+       * when the Ruby object is garbage collected.  If we don't
+       * do this, then it is possible we will return a reference 
+       * to a Ruby object that no longer exists thereby crashing Ruby. */
+      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
+    } else {    
+      RDATA(obj)->dfree = 0;
+    }
+  }
+
+  /* Do type-checking if type info was provided */
+  if (ty) {
+    if (ty->clientdata) {
+      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
+        if (vptr == 0) {
+          /* The object has already been deleted */
+          return SWIG_ObjectPreviouslyDeletedError;
+        }
+      }
+    }
+    if ((c = SWIG_MangleStr(obj)) == NULL) {
+      return SWIG_ERROR;
+    }
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) {
+      return SWIG_ERROR;
+    } else {
+      if (ptr) {
+        if (tc->type == ty) {
+          *ptr = vptr;
+        } else {
+          int newmemory = 0;
+          *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
+          if (newmemory == SWIG_CAST_NEW_MEMORY) {
+            assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+            if (own)
+              own->own = own->own | SWIG_CAST_NEW_MEMORY;
+          }
+        }
+      }
+    }
+  } else {
+    if (ptr)
+      *ptr = vptr;
+  }
+  
+  return SWIG_OK;
+}
+
+/* Check convert */
+SWIGRUNTIMEINLINE int
+SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
+{
+  char *c = SWIG_MangleStr(obj);
+  if (!c) return 0;
+  return SWIG_TypeCheck(c,ty) != 0;
+}
+
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r, ptr, sz);
+  strcpy(r, type->name);
+  return rb_str_new2(result);
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c;
+
+  if (TYPE(obj) != T_STRING) goto type_error;
+  c = StringValuePtr(obj);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') goto type_error;
+  c++;
+  c = SWIG_UnpackData(c, ptr, sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) goto type_error;
+  }
+  return SWIG_OK;
+
+ type_error:
+  return SWIG_ERROR;
+}
+
+SWIGRUNTIME swig_module_info *
+SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
+{
+  VALUE pointer;
+  swig_module_info *ret = 0;
+  VALUE verbose = rb_gv_get("VERBOSE");
+
+ /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
+  rb_gv_set("VERBOSE", Qfalse);
+  
+  /* first check if pointer already created */
+  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  if (pointer != Qnil) {
+    Data_Get_Struct(pointer, swig_module_info, ret);
+  }
+
+  /* reinstate warnings */
+  rb_gv_set("VERBOSE", verbose);
+  return ret;
+}
+
+SWIGRUNTIME void 
+SWIG_Ruby_SetModule(swig_module_info *pointer)
+{
+  /* register a new class */
+  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
+  /* create and store the structure pointer to a global variable */
+  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
+  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
+}
+
+/* This function can be used to check whether a proc or method or similarly
+   callable function has been passed.  Usually used in a %typecheck, like:
+
+   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
+        $result = SWIG_Ruby_isCallable( $input );
+   }
+ */
+SWIGINTERN
+int SWIG_Ruby_isCallable( VALUE proc )
+{
+  if ( rb_respond_to( proc, swig_call_id ) )
+    return 1;
+  return 0;
+}
+
+/* This function can be used to check the arity (number of arguments)
+   a proc or method can take.  Usually used in a %typecheck.
+   Valid arities will be that equal to minimal or those < 0
+   which indicate a variable number of parameters at the end.
+ */
+SWIGINTERN
+int SWIG_Ruby_arity( VALUE proc, int minimal )
+{
+  if ( rb_respond_to( proc, swig_arity_id ) )
+    {
+      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
+      int arity = NUM2INT(num);
+      if ( arity < 0 && (arity+1) < -minimal ) return 1;
+      if ( arity == minimal ) return 1;
+      return 1;
+    }
+  return 0;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/share/swig/2.0.11/ruby/rubyruntime.swg b/share/swig/3.0.12/ruby/rubyruntime.swg
index 4121561..4121561 100644
--- a/share/swig/2.0.11/ruby/rubyruntime.swg
+++ b/share/swig/3.0.12/ruby/rubyruntime.swg
diff --git a/share/swig/2.0.11/ruby/rubystdautodoc.swg b/share/swig/3.0.12/ruby/rubystdautodoc.swg
index e14f659..e14f659 100644
--- a/share/swig/2.0.11/ruby/rubystdautodoc.swg
+++ b/share/swig/3.0.12/ruby/rubystdautodoc.swg
diff --git a/share/swig/3.0.12/ruby/rubystdcommon.swg b/share/swig/3.0.12/ruby/rubystdcommon.swg
new file mode 100644
index 0000000..f72745b
--- /dev/null
+++ b/share/swig/3.0.12/ruby/rubystdcommon.swg
@@ -0,0 +1,203 @@
+
+/* ------------------------------------------------------------
+ * The Ruby classes, for C++
+ * ------------------------------------------------------------ */
+%include <rubyclasses.swg>
+
+%fragment("StdTraits","header",fragment="StdTraitsCommon")
+{
+
+namespace swig {  
+  /*
+    Traits that provides the from method
+  */
+  template <class Type> struct traits_from_ptr {
+    static VALUE from(Type *val, int owner = 0) {
+      return SWIG_NewPointerObj(val, type_info<Type>(), owner);
+    }
+  };
+
+  template <class Type> struct traits_from {
+    static VALUE from(const Type& val) {
+      return traits_from_ptr<Type>::from(new Type(val), 1);
+    }
+  };
+
+  template <class Type> struct traits_from<Type *> {
+    static VALUE from(Type* val) {
+      return traits_from_ptr<Type>::from(val, 0);
+    }
+  };
+
+  template <class Type> struct traits_from<const Type *> {
+    static VALUE from(const Type* val) {
+      return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
+    }
+  };
+
+
+  template <class Type>
+  inline VALUE from(const Type& val) {
+    return traits_from<Type>::from(val);
+  }
+
+  template <class Type>
+  inline VALUE from_ptr(Type* val, int owner) {
+    return traits_from_ptr<Type>::from(val, owner);
+  }
+
+  /*
+    Traits that provides the asval/as/check method
+  */
+  template <class Type>
+  struct traits_asptr {   
+    static int asptr(VALUE obj, Type **val) {
+      Type *p;
+      swig_type_info *descriptor = type_info<Type>();
+      int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
+      if (SWIG_IsOK(res)) {
+	if (val) *val = p;
+      }
+      return res;
+    }
+  }; 
+
+  template <class Type>
+  inline int asptr(VALUE obj, Type **vptr) {
+    return traits_asptr<Type>::asptr(obj, vptr);
+  }
+
+  template <class Type> 
+  struct traits_asval {
+    static int asval(VALUE obj, Type *val) {
+      if (val) {
+	Type *p = 0;
+	int res = traits_asptr<Type>::asptr(obj, &p);
+	if (!SWIG_IsOK(res)) return res;	
+	if (p) {
+	  typedef typename noconst_traits<Type>::noconst_type noconst_type;
+	  *(const_cast<noconst_type*>(val)) = *p;
+	  if (SWIG_IsNewObj(res)){
+	    %delete(p);
+	    res = SWIG_DelNewMask(res);
+	  }
+	  return res;
+	} else {
+	  return SWIG_ERROR;
+	}
+      } else {
+	return traits_asptr<Type>::asptr(obj, (Type **)(0));
+      }
+    }
+  };
+
+  template <class Type> struct traits_asval<Type*> {
+    static int asval(VALUE obj, Type **val) {
+      if (val) {
+        typedef typename noconst_traits<Type>::noconst_type noconst_type;
+        noconst_type *p = 0;
+        int res = traits_asptr<noconst_type>::asptr(obj,  &p);
+        if (SWIG_IsOK(res)) {
+          *(const_cast<noconst_type**>(val)) = p;
+	}
+	return res;
+      } else {
+	return traits_asptr<Type>::asptr(obj, (Type **)(0));
+      }
+    }
+  };
+  
+  template <class Type>
+  inline int asval(VALUE obj, Type *val) {
+    return traits_asval<Type>::asval(obj, val);
+  }
+
+  template <class Type> 
+  struct traits_as<Type, value_category> {
+    static Type as(VALUE obj, bool throw_error) {
+      Type v;
+      int res = asval(obj, &v);
+      if (!obj || !SWIG_IsOK(res)) {
+	if (throw_error) throw std::invalid_argument("bad type");
+	VALUE lastErr = rb_gv_get("$!");
+	if (lastErr == Qnil) {
+	  %type_error(swig::type_name<Type>());
+	}
+      }
+      return v;
+    }
+  };
+
+  template <class Type> 
+  struct traits_as<Type, pointer_category> {
+    static Type as(VALUE obj, bool throw_error) {
+      Type *v = 0;      
+      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
+      if (SWIG_IsOK(res) && v) {
+	if (SWIG_IsNewObj(res)) {
+	  Type r(*v);
+	  %delete(v);
+	  return r;
+	} else {
+	  return *v;
+	}
+      } else {
+	// Uninitialized return value, no Type() constructor required.
+	if (throw_error) throw std::invalid_argument("bad type");
+	VALUE lastErr = rb_gv_get("$!");
+	if (lastErr == Qnil) {
+	  %type_error(swig::type_name<Type>());
+	}
+	static Type *v_def = (Type*) malloc(sizeof(Type));
+	memset(v_def,0,sizeof(Type));
+	return *v_def;
+      }
+    }
+  };
+
+  template <class Type> 
+  struct traits_as<Type*, pointer_category> {
+    static Type* as(VALUE obj, bool throw_error) {
+      Type *v = 0;      
+      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
+      if (SWIG_IsOK(res)) {
+	return v;
+      } else {
+	if (throw_error) throw std::invalid_argument("bad type");
+	VALUE lastErr = rb_gv_get("$!");
+	if (lastErr == Qnil) {
+	  %type_error(swig::type_name<Type>());
+	}
+	return 0;
+      }
+    }
+  };
+
+  template <class Type>
+  inline Type as(VALUE obj, bool te = false) {
+    return traits_as< Type, typename traits< Type >::category >::as(obj, te);
+  }
+
+  template <class Type> 
+  struct traits_check<Type, value_category> {
+    static bool check(VALUE obj) {
+      int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
+      return SWIG_IsOK(res) ? true : false;
+    }
+  };
+
+  template <class Type> 
+  struct traits_check<Type, pointer_category> {
+    static bool check(VALUE obj) {
+      int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
+      return SWIG_IsOK(res) ? true : false;
+    }
+  };
+
+  template <class Type>
+  inline bool check(VALUE obj) {
+    return traits_check<Type, typename traits<Type>::category>::check(obj);
+  }
+}
+}
+
diff --git a/share/swig/3.0.12/ruby/rubystdfunctors.swg b/share/swig/3.0.12/ruby/rubystdfunctors.swg
new file mode 100644
index 0000000..5150333
--- /dev/null
+++ b/share/swig/3.0.12/ruby/rubystdfunctors.swg
@@ -0,0 +1,162 @@
+/**
+ * @file   rubystdfunctors.swg
+ * @date   Sun May  6 00:44:33 2007
+ * 
+ * @brief  This file provides unary and binary functors for STL
+ *         containers, that will invoke a Ruby proc or method to do
+ *         their operation.
+ *
+ *         You can use them in a swig file like:
+ *
+ *         %include <std_set.i>
+ *         %include <std_functors.i>
+ *
+ *         %template< IntSet > std::set< int, swig::BinaryPredicate<> >;
+ *
+ *
+ *         which will then allow calling them from Ruby either like:
+ *  
+ *            # order of set is defined by C++ default
+ *            a = IntSet.new
+ *
+ *            # sort order defined by Ruby proc
+ *            b = IntSet.new( proc { |a,b| a > b } )
+ * 
+ */
+
+%include rubyclasses.swg
+
+
+namespace swig {
+
+  %apply GC_VALUE { UnaryPredicate, BinaryPredicate, UnaryFunction,
+		      BinaryFunction };
+
+  %typecheck(SWIG_TYPECHECK_POINTER,noblock=1) 
+    UnaryPredicate, UnaryPredicate&, UnaryFunction, UnaryFunction&
+  {
+    $1 = SWIG_Ruby_isCallable($input) && SWIG_Ruby_arity($input, 1);
+  }
+
+  %typecheck(SWIG_TYPECHECK_POINTER,noblock=1) 
+    BinaryPredicate, BinaryPredicate&, BinaryFunction, BinaryFunction& {
+    $1 = SWIG_Ruby_isCallable($input) && SWIG_Ruby_arity($input, 2);
+  }
+
+  %typemap(in,noblock=1)  BinaryFunction&, BinaryFunction {
+    $1 = new swig::BinaryFunction< >($input);
+  }
+  %typemap(in,noblock=1) UnaryFunction&, UnaryFunction {
+    $1 = new swig::UnaryFunction< >($input);
+  }
+
+  %typemap(in,noblock=1) BinaryPredicate&, BinaryPredicate {
+    $1 = new swig::BinaryPredicate<>($input);
+  }
+
+  %typemap(in,noblock=1) UnaryPredicate&, UnaryPredicate {
+    $1 = new swig::UnaryPredicate< >($input);
+  }
+
+
+  %ignore BinaryFunction;
+  template< class _T = GC_VALUE >
+  struct BinaryFunction {
+  };
+
+  %ignore UnaryFunction;
+  template< class _T = GC_VALUE >
+  struct UnaryFunction {
+  };
+
+  %ignore BinaryPredicate;
+  template< class _T = GC_VALUE >
+  struct BinaryPredicate {
+  };
+
+  %ignore UnaryPredicate;
+  template< class _T = GC_VALUE >
+  struct UnaryPredicate {
+
+  };
+
+}
+
+
+%fragment("StdFunctors","header",fragment="StdTraits",fragment="GC_VALUE_definition")
+{
+namespace swig {
+
+  static ID call_id = rb_intern("call");
+
+  template <class _T = GC_VALUE, class _DefaultFunc = std::less<GC_VALUE> >
+  struct BinaryPredicate : GC_VALUE
+  {
+    BinaryPredicate(VALUE obj = Qnil) : GC_VALUE(obj) { }
+    bool operator()(_T a, _T b) const
+    {
+      if (_obj != Qnil) {
+        SWIG_RUBY_THREAD_BEGIN_BLOCK;
+	VALUE arg1 = swig::from(a);
+	VALUE arg2 = swig::from(b);
+	VALUE res = rb_funcall( _obj, swig::call_id, 2, arg1, arg2);
+        SWIG_RUBY_THREAD_END_BLOCK;
+        return RTEST(res);
+      } else {
+        return _DefaultFunc()(a, b);
+      }
+    }
+  };
+
+  template <class _T = GC_VALUE, class _DefaultFunc = std::less< _T > >
+  struct BinaryFunction : GC_VALUE
+  {
+    BinaryFunction(VALUE obj = Qnil) : GC_VALUE(obj) { }
+    _T operator()(_T a, _T b) const
+    {
+      if (_obj != Qnil) {
+        SWIG_RUBY_THREAD_BEGIN_BLOCK;
+	VALUE arg1 = swig::from(a);
+	VALUE arg2 = swig::from(b);
+	VALUE res = rb_funcall( _obj, swig::call_id, 2, arg1, arg2);
+        SWIG_RUBY_THREAD_END_BLOCK;
+        return swig::as<_T >(res);
+      } else {
+        return _DefaultFunc()(a, b);
+      }
+    }
+  };
+
+  template< class _T = GC_VALUE >
+  struct UnaryPredicate : GC_VALUE
+  {
+    UnaryPredicate(VALUE obj = Qnil) : GC_VALUE(obj) { }
+    bool operator()(_T a) const
+    {
+      SWIG_RUBY_THREAD_BEGIN_BLOCK;
+      VALUE arg1 = swig::from<_T >(a);
+      VALUE res = rb_funcall( _obj, swig::call_id, 1, arg1);
+      SWIG_RUBY_THREAD_END_BLOCK;
+      return RTEST(res);
+    }
+  };
+
+  template< class _T = GC_VALUE >
+  struct UnaryFunction : GC_VALUE
+  {
+    UnaryFunction(VALUE obj = Qnil) : GC_VALUE(obj) { }
+    _T operator()(_T a) const
+    {
+      SWIG_RUBY_THREAD_BEGIN_BLOCK;
+      VALUE arg1 = swig::from(a);
+      VALUE res = rb_funcall( _obj, swig::call_id, 1, VALUE(arg1));
+      SWIG_RUBY_THREAD_END_BLOCK;
+      return swig::as< _T >(res);
+    }
+  };
+
+} // namespace swig
+
+}
+
+
diff --git a/share/swig/2.0.11/ruby/rubystrings.swg b/share/swig/3.0.12/ruby/rubystrings.swg
index 3adf000..3adf000 100644
--- a/share/swig/2.0.11/ruby/rubystrings.swg
+++ b/share/swig/3.0.12/ruby/rubystrings.swg
diff --git a/share/swig/3.0.12/ruby/rubytracking.swg b/share/swig/3.0.12/ruby/rubytracking.swg
new file mode 100644
index 0000000..8f9f01b
--- /dev/null
+++ b/share/swig/3.0.12/ruby/rubytracking.swg
@@ -0,0 +1,131 @@
+/* -----------------------------------------------------------------------------
+ * rubytracking.swg
+ *
+ * This file contains support for tracking mappings from 
+ * Ruby objects to C++ objects.  This functionality is needed
+ * to implement mark functions for Ruby's mark and sweep
+ * garbage collector.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(ST_DATA_T_DEFINED)
+/* Needs to be explicitly included for Ruby 1.8 and earlier */
+#include <st.h>
+#endif
+
+/* Ruby 1.8 actually assumes the first case. */
+#if SIZEOF_VOIDP == SIZEOF_LONG
+#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
+#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
+#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
+#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
+#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
+#else
+#  error sizeof(void*) is not the same as long or long long
+#endif
+
+/* Global hash table to store Trackings from C/C++
+   structs to Ruby Objects. 
+*/
+static st_table* swig_ruby_trackings = NULL;
+
+static VALUE swig_ruby_trackings_count(ANYARGS) {
+  return SWIG2NUM(swig_ruby_trackings->num_entries);
+}
+
+
+/* Setup a hash table to store Trackings */
+SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
+  /* Create a hash table to store Trackings from C++
+     objects to Ruby objects. */
+
+  /* Try to see if some other .so has already created a 
+     tracking hash table, which we keep hidden in an instance var
+     in the SWIG module.
+     This is done to allow multiple DSOs to share the same
+     tracking table.
+  */
+  VALUE trackings_value = Qnil;
+  /* change the variable name so that we can mix modules
+     compiled with older SWIG's - this used to be called "@__trackings__" */
+  ID trackings_id = rb_intern( "@__safetrackings__" );
+  VALUE verbose = rb_gv_get("VERBOSE");
+  rb_gv_set("VERBOSE", Qfalse);
+  trackings_value = rb_ivar_get( _mSWIG, trackings_id );
+  rb_gv_set("VERBOSE", verbose);
+
+  /* The trick here is that we have to store the hash table
+  pointer in a Ruby variable. We do not want Ruby's GC to
+  treat this pointer as a Ruby object, so we convert it to
+  a Ruby numeric value. */
+  if (trackings_value == Qnil) {
+    /* No, it hasn't.  Create one ourselves */
+    swig_ruby_trackings = st_init_numtable();
+    rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
+  } else {
+    swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
+  }
+
+  rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", swig_ruby_trackings_count, NULL);
+}
+
+/* Add a Tracking from a C/C++ struct to a Ruby object */
+SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
+  /* Store the mapping to the global hash table. */
+  st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
+}
+
+/* Get the Ruby object that owns the specified C/C++ struct */
+SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
+  /* Now lookup the value stored in the global hash table */
+  VALUE value;
+
+  if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
+    return value;
+  } else {
+    return Qnil;
+  }
+}
+
+/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
+   is very important to remove objects once they are destroyed
+   since the same memory address may be reused later to create
+   a new object. */
+SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
+  /* Delete the object from the hash table */
+  st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
+}
+
+/* This is a helper method that unlinks a Ruby object from its
+   underlying C++ object.  This is needed if the lifetime of the
+   Ruby object is longer than the C++ object */
+SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
+  VALUE object = SWIG_RubyInstanceFor(ptr);
+
+  if (object != Qnil) {
+    if (TYPE(object) != T_DATA)
+      abort();
+    DATA_PTR(object) = 0;
+  }
+}
+
+/* This is a helper method that iterates over all the trackings
+   passing the C++ object pointer and its related Ruby object
+   to the passed callback function. */
+
+/* Proxy method to abstract the internal trackings datatype */
+static int swig_ruby_internal_iterate_callback(void* ptr, VALUE obj, void(*meth)(void* ptr, VALUE obj)) {
+  (*meth)(ptr, obj);
+  return ST_CONTINUE;
+}
+
+SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
+  st_foreach(swig_ruby_trackings, (int (*)(ANYARGS))&swig_ruby_internal_iterate_callback, (st_data_t)meth);
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/share/swig/3.0.12/ruby/rubytypemaps.swg b/share/swig/3.0.12/ruby/rubytypemaps.swg
new file mode 100644
index 0000000..3837df0
--- /dev/null
+++ b/share/swig/3.0.12/ruby/rubytypemaps.swg
@@ -0,0 +1,62 @@
+/* ------------------------------------------------------------
+ *  Typemap specializations for Ruby
+ * ------------------------------------------------------------ */
+/* ------------------------------------------------------------
+ *  Fragment section
+ * ------------------------------------------------------------ */
+/* bool is dangerous in Ruby, change precedence */
+#undef SWIG_TYPECHECK_BOOL
+%define SWIG_TYPECHECK_BOOL             10000 %enddef
+
+/* Include fundamental fragment definitions */
+%include <typemaps/fragments.swg>
+
+/* Look for user fragments file. */
+%include <rubyfragments.swg>
+
+/* Ruby fragments for primitive types */
+%include <rubyprimtypes.swg>
+
+/* Ruby fragments for char* strings */
+%include <rubystrings.swg>
+
+/* Backward compatibility output helper */
+%fragment("output_helper","header") %{
+#define output_helper SWIG_Ruby_AppendOutput
+%}
+
+/* ------------------------------------------------------------
+ *  Unified typemap section
+ * ------------------------------------------------------------ */
+
+/* Directors are supported in Ruby */
+#ifndef SWIG_DIRECTOR_TYPEMAPS
+#define SWIG_DIRECTOR_TYPEMAPS
+#endif
+
+
+/* Ruby types */
+#define SWIG_Object                      VALUE
+#define VOID_Object                      Qnil
+
+/* Overload of the output/constant/exception handling */
+
+/* append output */
+#define SWIG_AppendOutput(result,obj)    SWIG_Ruby_AppendOutput(result, obj)
+
+/* set constant */
+#define SWIG_SetConstant(name, obj)      rb_define_const($module, name, obj)
+
+/* raise */
+#define SWIG_Raise(obj, type, desc)      rb_exc_raise(SWIG_Ruby_ExceptionType(desc, obj)) 
+
+/* Get the address of the 'Ruby self' object */
+
+%typemap(in,numinputs=0,noblock=1) VALUE* RUBY_SELF {
+  $1 = &self;
+}
+
+/* Include the unified typemap library */
+%include <typemaps/swigtypemaps.swg>
+
+
diff --git a/share/swig/2.0.11/ruby/rubyuserdir.swg b/share/swig/3.0.12/ruby/rubyuserdir.swg
index 638433c..638433c 100644
--- a/share/swig/2.0.11/ruby/rubyuserdir.swg
+++ b/share/swig/3.0.12/ruby/rubyuserdir.swg
diff --git a/share/swig/3.0.12/ruby/rubywstrings.swg b/share/swig/3.0.12/ruby/rubywstrings.swg
new file mode 100644
index 0000000..b6dd937
--- /dev/null
+++ b/share/swig/3.0.12/ruby/rubywstrings.swg
@@ -0,0 +1,72 @@
+/* -----------------------------------------------------------------------------
+ * rubywstrings.swg
+ *
+ * Currently, Ruby does not support Unicode or WChar properly, so these
+ * are still treated as char arrays for now.
+ * There are other libraries available that add support to this in
+ * ruby including WString, FXString, etc.
+ * ----------------------------------------------------------------------------- */
+
+/* ------------------------------------------------------------
+ *  utility methods for wchar_t strings 
+ * ------------------------------------------------------------ */
+
+%fragment("SWIG_AsWCharPtrAndSize","header",fragment="<wchar.h>",fragment="SWIG_pwchar_descriptor",fragment="SWIG_AsCharPtrAndSize") {
+SWIGINTERN int
+SWIG_AsWCharPtrAndSize(VALUE obj, wchar_t **cptr, size_t *psize, int *alloc)
+{
+  return SWIG_AsCharPtrAndSize( obj, (char**)cptr, psize, alloc);
+//   VALUE tmp = 0;
+//   bool ok = false;
+//   if ( TYPE(obj) == T_STRING ) {
+//     if (cptr) {
+//       obj = tmp = SWIG_Unicode_FromObject(obj);
+//       ok = true;
+//     }
+//   }
+//   if (ok) {
+//     Py_ssize_t len = PyUnicode_GetSize(obj);
+//     rb_notimplement();
+//     if (cptr) {
+//       *cptr = %new_array(len + 1, wchar_t);
+//       SWIG_Unicode_AsWideChar((PyUnicodeObject *)obj, *cptr, len);
+//       (*cptr)[len] = 0;
+//     }
+//     if (psize) *psize = (size_t) len + 1;
+//     if (alloc) *alloc = cptr ? SWIG_NEWOBJ : 0;
+//     return SWIG_OK;
+//   } else {
+//     swig_type_info* pwchar_descriptor = SWIG_pwchar_descriptor();
+//     if (pwchar_descriptor) {
+//       void * vptr = 0;
+//       if (SWIG_ConvertPtr(obj, &vptr, pwchar_descriptor, 0) == SWIG_OK) {
+// 	if (cptr) *cptr = (wchar_t *)vptr;
+// 	if (psize) *psize = vptr ? (wcslen((wchar_t *)vptr) + 1) : 0;
+// 	return SWIG_OK;
+//       }
+//     }
+//   }
+//   return SWIG_TypeError;
+}
+}
+
+%fragment("SWIG_FromWCharPtrAndSize","header",fragment="<wchar.h>",fragment="SWIG_pwchar_descriptor",fragment="SWIG_FromCharPtrAndSize") {
+SWIGINTERNINLINE VALUE 
+SWIG_FromWCharPtrAndSize(const wchar_t * carray, size_t size)
+{
+  return SWIG_FromCharPtrAndSize( (const char*)carray, size);
+//   if (carray) {
+//     if (size > INT_MAX) {
+//       swig_type_info* pwchar_descriptor = SWIG_pwchar_descriptor();
+//       return pwchar_descriptor ? 
+// 	SWIG_NewPointerObj(%const_cast(carray,wchar_t *), pwchar_descriptor, 0) : Qnil;
+//     } else {
+//       return SWIG_Unicode_FromWideChar(carray, %numeric_cast(size,int));
+//     }
+//   } else {
+//     return Qnil;
+//   }
+}
+}
+
+
diff --git a/share/swig/2.0.11/ruby/std_alloc.i b/share/swig/3.0.12/ruby/std_alloc.i
index 35dc051..35dc051 100644
--- a/share/swig/2.0.11/ruby/std_alloc.i
+++ b/share/swig/3.0.12/ruby/std_alloc.i
diff --git a/share/swig/3.0.12/ruby/std_array.i b/share/swig/3.0.12/ruby/std_array.i
new file mode 100644
index 0000000..a4d3ef5
--- /dev/null
+++ b/share/swig/3.0.12/ruby/std_array.i
@@ -0,0 +1,102 @@
+/*
+  std::array
+*/
+
+%fragment("StdArrayTraits","header",fragment="StdSequenceTraits")
+%{
+  namespace swig {
+    template <class T, size_t N>
+    struct traits_asptr<std::array<T, N> >  {
+      static int asptr(VALUE obj, std::array<T, N> **vec) {
+	return traits_asptr_stdseq<std::array<T, N> >::asptr(obj, vec);
+      }
+    };
+    
+    template <class T, size_t N>
+    struct traits_from<std::array<T, N> > {
+      static VALUE from(const std::array<T, N>& vec) {
+	return traits_from_stdseq<std::array<T, N> >::from(vec);
+      }
+    };
+
+    template <class RubySeq, class T, size_t N>
+    inline void
+    assign(const RubySeq& rubyseq, std::array<T, N>* seq) {
+      if (rubyseq.size() < seq->size())
+        throw std::invalid_argument("std::array cannot be expanded in size");
+      else if (rubyseq.size() > seq->size())
+        throw std::invalid_argument("std::array cannot be reduced in size");
+      std::copy(rubyseq.begin(), rubyseq.end(), seq->begin());
+    }
+
+    template <class T, size_t N>
+    inline void
+    resize(std::array<T, N> *seq, typename std::array<T, N>::size_type n, typename std::array<T, N>::value_type x) {
+      throw std::invalid_argument("std::array is a fixed size container and does not support resizing");
+    }
+
+    // Only limited slicing is supported as std::array is fixed in size
+    template <class T, size_t N, class Difference>
+    inline std::array<T, N>*
+    getslice(const std::array<T, N>* self, Difference i, Difference j) {
+      typedef std::array<T, N> Sequence;
+      typename Sequence::size_type size = self->size();
+      typename Sequence::size_type ii = swig::check_index(i, size, (i == size && j == size));
+      typename Sequence::size_type jj = swig::slice_index(j, size);
+
+      if (ii == 0 && jj == size) {
+        Sequence *sequence = new Sequence();
+        std::copy(self->begin(), self->end(), sequence->begin());
+        return sequence;
+      } else {
+        throw std::invalid_argument("std::array object only supports getting a slice that is the size of the array");
+      }
+    }
+
+    template <class T, size_t N, class Difference, class InputSeq>
+    inline void
+    setslice(std::array<T, N>* self, Difference i, Difference j, const InputSeq& v) {
+      typedef std::array<T, N> Sequence;
+      typename Sequence::size_type size = self->size();
+      typename Sequence::size_type ii = swig::check_index(i, size, true);
+      typename Sequence::size_type jj = swig::slice_index(j, size);
+
+      if (ii == 0 && jj == size) {
+        std::copy(v.begin(), v.end(), self->begin());
+      } else {
+        throw std::invalid_argument("std::array object only supports setting a slice that is the size of the array");
+      }
+    }
+
+    template <class T, size_t N, class Difference>
+    inline void
+    delslice(std::array<T, N>* self, Difference i, Difference j) {
+      throw std::invalid_argument("std::array object does not support item deletion");
+    }
+  }
+%}
+
+
+%define %swig_array_methods(Type...)
+  %swig_sequence_methods_non_resizable(Type)
+%enddef
+
+%define %swig_array_methods_val(Type...)
+  %swig_sequence_methods_non_resizable_val(Type);
+%enddef
+
+
+%mixin std::array "Enumerable";
+%ignore std::array::push_back;
+%ignore std::array::pop_back;
+
+
+%rename("delete")     std::array::__delete__;
+%rename("reject!")    std::array::reject_bang;
+%rename("map!")       std::array::map_bang;
+%rename("empty?")     std::array::empty;
+%rename("include?" )  std::array::__contains__ const;
+%rename("has_key?" )  std::array::has_key const;
+
+%include <std/std_array.i>
+
diff --git a/share/swig/2.0.11/ruby/std_basic_string.i b/share/swig/3.0.12/ruby/std_basic_string.i
index 1351177..1351177 100644
--- a/share/swig/2.0.11/ruby/std_basic_string.i
+++ b/share/swig/3.0.12/ruby/std_basic_string.i
diff --git a/share/swig/2.0.11/ruby/std_char_traits.i b/share/swig/3.0.12/ruby/std_char_traits.i
index bf4e6c4..bf4e6c4 100644
--- a/share/swig/2.0.11/ruby/std_char_traits.i
+++ b/share/swig/3.0.12/ruby/std_char_traits.i
diff --git a/share/swig/3.0.12/ruby/std_common.i b/share/swig/3.0.12/ruby/std_common.i
new file mode 100644
index 0000000..0cf9ce1
--- /dev/null
+++ b/share/swig/3.0.12/ruby/std_common.i
@@ -0,0 +1,74 @@
+%include <std/std_except.i>
+%include <rubystdcommon.swg>
+%include <rubystdautodoc.swg>
+
+
+/*
+  Generate the traits for a 'primitive' type, such as 'double',
+  for which the SWIG_AsVal and SWIG_From methods are already defined.
+*/
+
+%define %traits_ptypen(Type...)
+  %fragment(SWIG_Traits_frag(Type),"header",
+	    fragment=SWIG_AsVal_frag(Type),
+	    fragment=SWIG_From_frag(Type),
+	    fragment="StdTraits") {
+namespace swig {
+  template <> struct traits< Type > {
+    typedef value_category category;
+    static const char* type_name() { return  #Type; }
+  };
+  template <>  struct traits_asval< Type > {
+    typedef Type value_type;
+    static int asval(VALUE obj, value_type *val) {
+      return SWIG_AsVal(Type)(obj, val);
+    }
+  };
+  template <>  struct traits_from< Type > {
+    typedef Type value_type;
+    static VALUE from(const value_type& val) {
+      return SWIG_From(Type)(val);
+    }
+  };
+}
+}
+%enddef
+
+/* Traits for enums. This is bit of a sneaky trick needed because a generic template specialization of enums
+   is not possible (unless using template meta-programming which SWIG doesn't support because of the explicit
+   instantiations required using %template). The STL containers define the 'front' method and the typemap
+   below is used whenever the front method is wrapped returning an enum. This typemap simply picks up the
+   standard enum typemap, but additionally drags in a fragment containing the traits_asval and traits_from
+   required in the generated code for enums. */
+
+%define %traits_enum(Type...)
+  %fragment("SWIG_Traits_enum_"{Type},"header",
+	    fragment=SWIG_AsVal_frag(int),
+	    fragment=SWIG_From_frag(int),
+	    fragment="StdTraits") {
+namespace swig {
+  template <>  struct traits_asval< Type > {
+    typedef Type value_type;
+    static int asval(VALUE obj, value_type *val) {
+      return SWIG_AsVal(int)(obj, (int *)val);
+    }
+  };
+  template <>  struct traits_from< Type > {
+    typedef Type value_type;
+    static VALUE from(const value_type& val) {
+      return SWIG_From(int)((int)val);
+    }
+  };
+}
+}
+%typemap(out, fragment="SWIG_Traits_enum_"{Type}) const enum SWIGTYPE& front %{$typemap(out, const enum SWIGTYPE&)%}
+%enddef
+
+
+%include <std/std_common.i>
+
+//
+// Generates the traits for all the known primitive
+// C++ types (int, double, ...)
+//
+%apply_cpptypes(%traits_ptypen);
diff --git a/share/swig/2.0.11/ruby/std_complex.i b/share/swig/3.0.12/ruby/std_complex.i
index dacbea2..dacbea2 100644
--- a/share/swig/2.0.11/ruby/std_complex.i
+++ b/share/swig/3.0.12/ruby/std_complex.i
diff --git a/share/swig/2.0.11/ruby/std_container.i b/share/swig/3.0.12/ruby/std_container.i
index 8537950..8537950 100644
--- a/share/swig/2.0.11/ruby/std_container.i
+++ b/share/swig/3.0.12/ruby/std_container.i
diff --git a/share/swig/2.0.11/ruby/std_deque.i b/share/swig/3.0.12/ruby/std_deque.i
index 38048af..38048af 100644
--- a/share/swig/2.0.11/ruby/std_deque.i
+++ b/share/swig/3.0.12/ruby/std_deque.i
diff --git a/share/swig/3.0.12/ruby/std_except.i b/share/swig/3.0.12/ruby/std_except.i
new file mode 100644
index 0000000..af98428
--- /dev/null
+++ b/share/swig/3.0.12/ruby/std_except.i
@@ -0,0 +1 @@
+%include <typemaps/std_except.swg>
diff --git a/share/swig/2.0.11/ruby/std_functors.i b/share/swig/3.0.12/ruby/std_functors.i
index 54ee97b..54ee97b 100644
--- a/share/swig/2.0.11/ruby/std_functors.i
+++ b/share/swig/3.0.12/ruby/std_functors.i
diff --git a/share/swig/2.0.11/ruby/std_ios.i b/share/swig/3.0.12/ruby/std_ios.i
index 7aafae2..7aafae2 100644
--- a/share/swig/2.0.11/ruby/std_ios.i
+++ b/share/swig/3.0.12/ruby/std_ios.i
diff --git a/share/swig/2.0.11/ruby/std_iostream.i b/share/swig/3.0.12/ruby/std_iostream.i
index ee36bec..ee36bec 100644
--- a/share/swig/2.0.11/ruby/std_iostream.i
+++ b/share/swig/3.0.12/ruby/std_iostream.i
diff --git a/share/swig/2.0.11/ruby/std_list.i b/share/swig/3.0.12/ruby/std_list.i
index 8d4284b..8d4284b 100644
--- a/share/swig/2.0.11/ruby/std_list.i
+++ b/share/swig/3.0.12/ruby/std_list.i
diff --git a/share/swig/3.0.12/ruby/std_map.i b/share/swig/3.0.12/ruby/std_map.i
new file mode 100644
index 0000000..7077fa1
--- /dev/null
+++ b/share/swig/3.0.12/ruby/std_map.i
@@ -0,0 +1,424 @@
+//
+//   Maps
+//
+%fragment("StdMapCommonTraits","header",fragment="StdSequenceTraits")
+{
+  namespace swig {
+    template <class ValueType>
+    struct from_key_oper 
+    {
+      typedef const ValueType& argument_type;
+      typedef  VALUE result_type;
+      result_type operator()(argument_type v) const
+      {
+	return swig::from(v.first);
+      }
+    };
+
+    template <class ValueType>
+    struct from_value_oper 
+    {
+      typedef const ValueType& argument_type;
+      typedef  VALUE result_type;
+      result_type operator()(argument_type v) const
+      {
+	return swig::from(v.second);
+      }
+    };
+
+    template<class OutIterator, class FromOper, 
+	     class ValueType = typename OutIterator::value_type>
+    struct MapIterator_T : ConstIteratorClosed_T<OutIterator, ValueType, FromOper>
+    {
+      MapIterator_T(OutIterator curr, OutIterator first, OutIterator last, VALUE seq)
+	: ConstIteratorClosed_T<OutIterator,ValueType,FromOper>(curr, first, last, seq)
+      {
+      }
+    };
+
+
+    template<class OutIterator,
+	     class FromOper = from_key_oper<typename OutIterator::value_type> >
+    struct MapKeyIterator_T : MapIterator_T<OutIterator, FromOper>
+    {
+      MapKeyIterator_T(OutIterator curr, OutIterator first, OutIterator last, VALUE seq)
+	: MapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
+      {
+      }
+    };
+
+    template<typename OutIter>
+    inline ConstIterator*
+    make_output_key_iterator(const OutIter& current, const OutIter& begin, 
+			     const OutIter& end, VALUE seq = 0)
+    {
+      return new MapKeyIterator_T<OutIter>(current, begin, end, seq);
+    }
+
+    template<class OutIterator,
+	     class FromOper = from_value_oper<typename OutIterator::value_type> >
+    struct MapValueIterator_T : MapIterator_T<OutIterator, FromOper>
+    {
+      MapValueIterator_T(OutIterator curr, OutIterator first, OutIterator last, VALUE seq)
+	: MapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
+      {
+      }
+    };
+    
+
+    template<typename OutIter>
+    inline ConstIterator*
+    make_output_value_iterator(const OutIter& current, const OutIter& begin, 
+			       const OutIter& end, VALUE seq = 0)
+    {
+      return new MapValueIterator_T<OutIter>(current, begin, end, seq);
+    }
+  }
+}
+
+%fragment("StdMapTraits","header",fragment="StdMapCommonTraits")
+{
+  namespace swig {
+    template <class RubySeq, class K, class T >
+    inline void
+    assign(const RubySeq& rubyseq, std::map<K,T > *map) {
+      typedef typename std::map<K,T>::value_type value_type;
+      typename RubySeq::const_iterator it = rubyseq.begin();
+      for (;it != rubyseq.end(); ++it) {
+	map->insert(value_type(it->first, it->second));
+      }
+    }
+
+    template <class K, class T>
+    struct traits_asptr<std::map<K,T> >  {
+      typedef std::map<K,T> map_type;
+      static int asptr(VALUE obj, map_type **val) {
+	int res = SWIG_ERROR;
+	if ( TYPE(obj) == T_HASH ) {
+	  static ID id_to_a = rb_intern("to_a");
+	  VALUE items = rb_funcall(obj, id_to_a, 0);
+	  res = traits_asptr_stdseq<std::map<K,T>, std::pair<K, T> >::asptr(items, val);
+	} else {
+	  map_type *p;
+	  swig_type_info *descriptor = swig::type_info<map_type>();
+	  res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
+	  if (SWIG_IsOK(res) && val)  *val = p;
+	}
+	return res;
+      }
+    };
+      
+    template <class K, class T >
+    struct traits_from<std::map<K,T> >  {
+      typedef std::map<K,T> map_type;
+      typedef typename map_type::const_iterator const_iterator;
+      typedef typename map_type::size_type size_type;
+            
+      static VALUE from(const map_type& map) {
+	swig_type_info *desc = swig::type_info<map_type>();
+	if (desc && desc->clientdata) {
+	  return SWIG_NewPointerObj(new map_type(map), desc, SWIG_POINTER_OWN);
+	} else {
+	  size_type size = map.size();
+	  int rubysize = (size <= (size_type) INT_MAX) ? (int) size : -1;
+	  if (rubysize < 0) {
+	    SWIG_RUBY_THREAD_BEGIN_BLOCK;
+	    rb_raise( rb_eRuntimeError, "map size not valid in Ruby");
+	    SWIG_RUBY_THREAD_END_BLOCK;
+	    return Qnil;
+	  }
+	  VALUE obj = rb_hash_new();
+	  for (const_iterator i= map.begin(); i!= map.end(); ++i) {
+	    VALUE key = swig::from(i->first);
+	    VALUE val = swig::from(i->second);
+	    rb_hash_aset(obj, key, val);
+	  }
+	  return obj;
+	}
+      }
+    };
+  }
+}
+
+%define %swig_map_common(Map...)
+  %swig_container_methods(%arg(Map));
+  // %swig_sequence_iterator(%arg(Map));
+
+  %extend {
+    
+    VALUE __delete__(const key_type& key) {
+      Map::iterator i = self->find(key);
+      if (i != self->end()) {
+	self->erase(i);
+	return swig::from( key );
+      }
+      else {
+	return Qnil;
+      }
+    }
+    
+    bool has_key(const key_type& key) const {
+      Map::const_iterator i = self->find(key);
+      return i != self->end();
+    }
+    
+    VALUE keys() {
+      Map::size_type size = self->size();
+      int rubysize = (size <= (Map::size_type) INT_MAX) ? (int) size : -1;
+      if (rubysize < 0) {
+	SWIG_RUBY_THREAD_BEGIN_BLOCK;
+	rb_raise(rb_eRuntimeError, "map size not valid in Ruby");
+	SWIG_RUBY_THREAD_END_BLOCK;
+	return Qnil;
+      }
+      VALUE ary = rb_ary_new2(rubysize);
+      Map::const_iterator i = self->begin();
+      Map::const_iterator e = self->end();
+      for ( ; i != e; ++i ) {
+	rb_ary_push( ary, swig::from(i->first) );
+      }
+      return ary;
+    }
+
+    Map* each()
+      {
+	if ( !rb_block_given_p() )
+	  rb_raise( rb_eArgError, "no block given");
+
+	VALUE k, v;
+	Map::iterator i = self->begin();
+	Map::iterator e = self->end();
+	for ( ; i != e; ++i )
+	  {
+	    const Map::key_type&    key = i->first;
+	    const Map::mapped_type& val = i->second;
+
+	    k = swig::from<Map::key_type>(key);
+	    v = swig::from<Map::mapped_type>(val);
+	    rb_yield_values(2, k, v);
+	  }
+	
+	return self;
+      }
+
+    %newobject select;
+    Map* select() {
+      if ( !rb_block_given_p() )
+	rb_raise( rb_eArgError, "no block given" );
+
+      Map* r = new Map;
+      Map::iterator i = $self->begin();
+      Map::iterator e = $self->end();
+      for ( ; i != e; ++i )
+	{
+	  VALUE k = swig::from<Map::key_type>(i->first);
+	  VALUE v = swig::from<Map::mapped_type>(i->second);
+	  if ( RTEST( rb_yield_values(2, k, v) ) )
+	    $self->insert(r->end(), *i);
+	}
+	
+      return r;
+    }
+
+  %typemap(in) (int argc, VALUE* argv) {
+    $1 = argc;
+    $2 = argv;
+  }
+
+  VALUE values_at(int argc, VALUE* argv, ...) {
+    
+    VALUE r = rb_ary_new();
+    ID   id = rb_intern("[]");
+    swig_type_info* type = swig::type_info< Map >();
+    VALUE me = SWIG_NewPointerObj( $self, type, 0 );
+    for ( int i = 0; i < argc; ++i )
+      {
+	VALUE key = argv[i];
+	VALUE tmp = rb_funcall( me, id, 1, key );
+	rb_ary_push( r, tmp );
+      }
+    
+    return r;
+  }
+
+
+    Map* each_key()
+      {
+	if ( !rb_block_given_p() )
+	  rb_raise( rb_eArgError, "no block given");
+
+	VALUE r;
+	Map::iterator i = self->begin();
+	Map::iterator e = self->end();
+	for ( ; i != e; ++i )
+	  {
+	    r = swig::from( i->first );
+	    rb_yield(r);
+	  }
+	
+	return self;
+      }
+    
+    VALUE values() {
+      Map::size_type size = self->size();
+      int rubysize = (size <= (Map::size_type) INT_MAX) ? (int) size : -1;
+      if (rubysize < 0) {
+	SWIG_RUBY_THREAD_BEGIN_BLOCK;
+	rb_raise(rb_eRuntimeError, "map size not valid in Ruby");
+	SWIG_RUBY_THREAD_END_BLOCK;
+	return Qnil;
+      }
+      VALUE ary = rb_ary_new2(rubysize);
+      Map::const_iterator i = self->begin();
+      Map::const_iterator e = self->end();
+      for ( ; i != e; ++i ) {
+	rb_ary_push( ary, swig::from(i->second) );
+      }
+      return ary;
+    }
+    
+    Map* each_value()
+      {
+	if ( !rb_block_given_p() )
+	  rb_raise( rb_eArgError, "no block given");
+
+	VALUE r;
+	Map::iterator i = self->begin();
+	Map::iterator e = self->end();
+	for ( ; i != e; ++i )
+	  {
+	    r = swig::from( i->second );
+	    rb_yield(r);
+	  }
+	
+	return self;
+      }
+
+    VALUE entries() {
+      Map::size_type size = self->size();
+      int rubysize = (size <= (Map::size_type) INT_MAX) ? (int) size : -1;
+      if (rubysize < 0) {
+	SWIG_RUBY_THREAD_BEGIN_BLOCK;
+	rb_raise(rb_eRuntimeError, "map size not valid in Ruby");
+	SWIG_RUBY_THREAD_END_BLOCK;
+	return Qnil;
+      }
+      VALUE ary = rb_ary_new2(rubysize);
+      Map::const_iterator i = self->begin();
+      Map::const_iterator e = self->end();
+      for ( ; i != e; ++i ) {
+	rb_ary_push( ary, swig::from<std::pair<Map::key_type, 
+		     Map::mapped_type> >(*i) );
+      }
+      return ary;
+    }
+    
+    bool __contains__(const key_type& key) {
+      return self->find(key) != self->end();
+    }
+
+    %newobject key_iterator(VALUE *RUBY_SELF);
+    swig::ConstIterator* key_iterator(VALUE *RUBY_SELF) {
+      return swig::make_output_key_iterator($self->begin(), $self->begin(), 
+					    $self->end(), *RUBY_SELF);
+    }
+
+    %newobject value_iterator(VALUE *RUBY_SELF);
+    swig::ConstIterator* value_iterator(VALUE *RUBY_SELF) {
+      return swig::make_output_value_iterator($self->begin(), $self->begin(), 
+					      $self->end(), *RUBY_SELF);
+    }
+
+  }
+%enddef
+
+%define %swig_map_methods(Map...)
+  %swig_map_common(Map)
+  %extend {
+    VALUE __getitem__(const key_type& key) const {
+      Map::const_iterator i = self->find(key);
+      if ( i != self->end() )
+	return swig::from<Map::mapped_type>( i->second );
+      else
+	return Qnil;
+    }
+
+    void __setitem__(const key_type& key, const mapped_type& x) throw (std::out_of_range) {
+      (*self)[key] = x;
+    }
+
+  VALUE inspect()
+    {
+      Map::const_iterator i = $self->begin();
+      Map::const_iterator e = $self->end();
+      const char *type_name = swig::type_name< Map >();
+      VALUE str = rb_str_new2( type_name );
+      str = rb_str_cat2( str, " {" );
+      bool comma = false;
+      VALUE tmp;
+      for ( ; i != e; ++i, comma = true )
+	{
+	  if (comma) str = rb_str_cat2( str, "," );
+	  tmp = swig::from< Map::key_type >( i->first );
+	  tmp = rb_inspect( tmp );
+	  str = rb_str_buf_append( str, tmp );
+	  str = rb_str_cat2( str, "=>" );
+	  tmp = swig::from< Map::mapped_type >( i->second );
+	  tmp = rb_inspect( tmp );
+	  str = rb_str_buf_append( str, tmp );
+	}
+      str = rb_str_cat2( str, "}" );
+      return str;
+    }
+
+  VALUE to_a()
+    {
+      Map::const_iterator i = $self->begin();
+      Map::const_iterator e = $self->end();
+      VALUE ary = rb_ary_new2( std::distance( i, e ) );
+      VALUE tmp;
+      for ( ; i != e; ++i )
+	{
+	  // @todo: improve -- this should just be swig::from(*i)
+	  tmp = swig::from< std::pair<Map::key_type, 
+	    Map::mapped_type> >( *i );
+	  rb_ary_push( ary, tmp );
+	}
+      return ary;
+    }
+
+  VALUE to_s()
+    {
+      Map::iterator i = $self->begin();
+      Map::iterator e = $self->end();
+      VALUE str = rb_str_new2( "" );
+      VALUE tmp;
+      for ( ; i != e; ++i )
+	{
+	  // @todo: improve -- this should just be swig::from(*i)
+	  tmp = swig::from< std::pair<Map::key_type, 
+	    Map::mapped_type> >( *i );
+	  tmp = rb_obj_as_string( tmp );
+	  str = rb_str_buf_append( str, tmp );
+	}
+      return str;
+    }
+
+  }
+%enddef
+
+
+%mixin std::map "Enumerable";
+
+
+%rename("delete")     std::map::__delete__;
+%rename("reject!")    std::map::reject_bang;
+%rename("map!")       std::map::map_bang;
+%rename("empty?")     std::map::empty;
+%rename("include?" )  std::map::__contains__ const;
+%rename("has_key?" )  std::map::has_key const;
+
+%alias  std::map::push          "<<";
+
+
+%include <std/std_map.i>
diff --git a/share/swig/2.0.11/ruby/std_multimap.i b/share/swig/3.0.12/ruby/std_multimap.i
index 3e06ee1..3e06ee1 100644
--- a/share/swig/2.0.11/ruby/std_multimap.i
+++ b/share/swig/3.0.12/ruby/std_multimap.i
diff --git a/share/swig/2.0.11/ruby/std_multiset.i b/share/swig/3.0.12/ruby/std_multiset.i
index 87a7b29..87a7b29 100644
--- a/share/swig/2.0.11/ruby/std_multiset.i
+++ b/share/swig/3.0.12/ruby/std_multiset.i
diff --git a/share/swig/3.0.12/ruby/std_pair.i b/share/swig/3.0.12/ruby/std_pair.i
new file mode 100644
index 0000000..38a4ffb
--- /dev/null
+++ b/share/swig/3.0.12/ruby/std_pair.i
@@ -0,0 +1,212 @@
+/*
+  Pairs
+*/
+%include <rubystdcommon.swg>
+
+//#define SWIG_STD_PAIR_ASVAL
+
+%fragment("StdPairTraits","header",fragment="StdTraits") {
+  namespace swig {
+
+    template <class T, class U >
+    struct traits_asval<std::pair<T,U> >  {
+      typedef std::pair<T,U> value_type;
+
+      static int get_pair(VALUE first, VALUE second,
+			  std::pair<T,U> *val)
+      {
+	if (val) {
+	  T *pfirst = &(val->first);
+	  int res1 = swig::asval((VALUE)first, pfirst);
+	  if (!SWIG_IsOK(res1)) return res1;
+	  U *psecond = &(val->second);
+	  int res2 = swig::asval((VALUE)second, psecond);
+	  if (!SWIG_IsOK(res2)) return res2;
+	  return res1 > res2 ? res1 : res2;
+	} else {
+	  T *pfirst = 0;
+	  int res1 = swig::asval((VALUE)first, pfirst);
+	  if (!SWIG_IsOK(res1)) return res1;
+	  U *psecond = 0;
+	  int res2 = swig::asval((VALUE)second, psecond);
+	  if (!SWIG_IsOK(res2)) return res2;
+	  return res1 > res2 ? res1 : res2;
+	}
+      }
+
+      static int asval(VALUE obj, std::pair<T,U> *val) {
+	int res = SWIG_ERROR;
+	if ( TYPE(obj) == T_ARRAY ) {
+	  if (RARRAY_LEN(obj) == 2) {
+	    VALUE first = rb_ary_entry(obj,0);
+	    VALUE second = rb_ary_entry(obj,1);
+	    res = get_pair(first, second, val);
+	  }
+	} else {
+	  value_type *p;
+	  swig_type_info *descriptor = swig::type_info<value_type>();
+	  res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
+	  if (SWIG_IsOK(res) && val)  *val = *p;
+	}
+	return res;
+      }
+    };
+
+    template <class T, class U >
+    struct traits_asptr<std::pair<T,U> >  {
+      typedef std::pair<T,U> value_type;
+
+      static int get_pair(VALUE first, VALUE second,
+			  std::pair<T,U> **val) 
+      {
+	if (val) {
+	  value_type *vp = %new_instance(std::pair<T,U>);
+	  T *pfirst = &(vp->first);
+	  int res1 = swig::asval((VALUE)first, pfirst);
+	  if (!SWIG_IsOK(res1)) {
+	    %delete(vp);
+	    return res1;
+	  }
+	  U *psecond = &(vp->second);
+	  int res2 = swig::asval((VALUE)second, psecond);
+	  if (!SWIG_IsOK(res2)) {
+	    %delete(vp);
+	    return res2;
+	  }
+	  *val = vp;
+	  return SWIG_AddNewMask(res1 > res2 ? res1 : res2);
+	} else {
+	  T *pfirst = 0;
+	  int res1 = swig::asval((VALUE)first, pfirst);
+	  if (!SWIG_IsOK(res1)) return res1;
+	  U *psecond = 0;
+	  int res2 = swig::asval((VALUE)second, psecond);
+	  if (!SWIG_IsOK(res2)) return res2;
+	  return res1 > res2 ? res1 : res2;
+	}
+      }
+
+      static int asptr(VALUE obj, std::pair<T,U> **val) {
+	int res = SWIG_ERROR;
+	if ( TYPE(obj) == T_ARRAY ) {
+	  if ( RARRAY_LEN(obj) == 2) {
+	    VALUE first = rb_ary_entry(obj,0);
+	    VALUE second = rb_ary_entry(obj,1);
+	    res = get_pair(first, second, val);
+	  }
+	} else {
+	  value_type *p;
+	  swig_type_info *descriptor = swig::type_info<value_type>();
+	  res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
+	  if (SWIG_IsOK(res) && val)  *val = p;
+	}
+	return res;
+      }
+    };
+
+
+
+    template <class T, class U >
+    struct traits_from<std::pair<T,U> >   {
+      static VALUE _wrap_pair_second( VALUE self )
+      {
+	std::pair< typename swig::noconst_traits<T >::noconst_type,U>* p = NULL;
+	swig::asptr( self, &p );
+	return swig::from( p->second );
+      }
+
+      static VALUE _wrap_pair_second_eq( VALUE self, VALUE arg )
+      {
+	std::pair< typename swig::noconst_traits<T >::noconst_type,U>* p = NULL;
+	swig::asptr( self, &p );
+	return swig::from( p->second );
+      }
+
+      static VALUE from(const std::pair<T,U>& val) {
+	VALUE obj = rb_ary_new2(2);
+	rb_ary_push(obj, swig::from<typename swig::noconst_traits<T >::noconst_type>(val.first));
+	rb_ary_push(obj, swig::from(val.second));
+	rb_define_singleton_method(obj, "second",
+				   VALUEFUNC(_wrap_pair_second), 0 );
+	rb_define_singleton_method(obj, "second=",
+				   VALUEFUNC(_wrap_pair_second_eq), 1 );
+	rb_obj_freeze(obj); // treat as immutable tuple
+	return obj;
+      }
+    };
+
+  }
+}
+
+// Missing typemap
+%typemap(in) std::pair* (int res) {
+  res = swig::asptr( $input, &$1 );
+  if (!SWIG_IsOK(res))
+    %argument_fail(res, "$1_type", $symname, $argnum); 
+}
+
+
+%define %swig_pair_methods(pair...)
+
+%extend { 
+  VALUE inspect() const
+    {
+      VALUE tmp;
+      const char *type_name = swig::type_name< pair >();
+      VALUE str = rb_str_new2( type_name );
+      str = rb_str_cat2( str, " (" );
+      tmp = swig::from( $self->first );
+      tmp = rb_obj_as_string( tmp );
+      str = rb_str_buf_append( str, tmp );
+      str = rb_str_cat2( str, "," );
+      tmp = swig::from( $self->second );
+      tmp = rb_obj_as_string( tmp );
+      str = rb_str_buf_append( str, tmp );
+      str = rb_str_cat2( str, ")" );
+      return str;
+    }
+
+  VALUE to_s() const
+    {
+      VALUE tmp;
+      VALUE str = rb_str_new2( "(" );
+      tmp = swig::from( $self->first );
+      tmp = rb_obj_as_string( tmp );
+      str = rb_str_buf_append( str, tmp );
+      str = rb_str_cat2( str, "," );
+      tmp = swig::from( $self->second );
+      tmp = rb_obj_as_string( tmp );
+      str = rb_str_buf_append( str, tmp );
+      str = rb_str_cat2( str, ")" );
+      return str;
+    }
+
+  VALUE __getitem__( int index )
+    { 
+      if (( index % 2 ) == 0 )
+	return swig::from( $self->first );
+      else
+	return swig::from( $self->second );
+    }
+
+  VALUE __setitem__( int index, VALUE obj )
+    { 
+      int res;
+      if (( index % 2 ) == 0 )
+	{
+	  res = swig::asval( obj, &($self->first) );
+	}
+      else
+	{
+	  res = swig::asval(obj, &($self->second) );
+	}
+      if (!SWIG_IsOK(res))
+	rb_raise( rb_eArgError, "invalid item for " #pair );
+      return obj;
+    }
+
+  } // extend
+
+%enddef
+
+%include <std/std_pair.i>
diff --git a/share/swig/2.0.11/ruby/std_queue.i b/share/swig/3.0.12/ruby/std_queue.i
index a129367..a129367 100644
--- a/share/swig/2.0.11/ruby/std_queue.i
+++ b/share/swig/3.0.12/ruby/std_queue.i
diff --git a/share/swig/2.0.11/ruby/std_set.i b/share/swig/3.0.12/ruby/std_set.i
index e38702e..e38702e 100644
--- a/share/swig/2.0.11/ruby/std_set.i
+++ b/share/swig/3.0.12/ruby/std_set.i
diff --git a/share/swig/3.0.12/ruby/std_shared_ptr.i b/share/swig/3.0.12/ruby/std_shared_ptr.i
new file mode 100644
index 0000000..df87367
--- /dev/null
+++ b/share/swig/3.0.12/ruby/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/ruby/std_sstream.i b/share/swig/3.0.12/ruby/std_sstream.i
index 537a3ae..537a3ae 100644
--- a/share/swig/2.0.11/ruby/std_sstream.i
+++ b/share/swig/3.0.12/ruby/std_sstream.i
diff --git a/share/swig/2.0.11/ruby/std_stack.i b/share/swig/3.0.12/ruby/std_stack.i
index 600c81c..600c81c 100644
--- a/share/swig/2.0.11/ruby/std_stack.i
+++ b/share/swig/3.0.12/ruby/std_stack.i
diff --git a/share/swig/2.0.11/ruby/std_streambuf.i b/share/swig/3.0.12/ruby/std_streambuf.i
index 44b9bb4..44b9bb4 100644
--- a/share/swig/2.0.11/ruby/std_streambuf.i
+++ b/share/swig/3.0.12/ruby/std_streambuf.i
diff --git a/share/swig/2.0.11/ruby/std_string.i b/share/swig/3.0.12/ruby/std_string.i
index cac4324..cac4324 100644
--- a/share/swig/2.0.11/ruby/std_string.i
+++ b/share/swig/3.0.12/ruby/std_string.i
diff --git a/share/swig/2.0.11/ruby/std_vector.i b/share/swig/3.0.12/ruby/std_vector.i
index 67fdcd1..67fdcd1 100644
--- a/share/swig/2.0.11/ruby/std_vector.i
+++ b/share/swig/3.0.12/ruby/std_vector.i
diff --git a/share/swig/2.0.11/ruby/std_vectora.i b/share/swig/3.0.12/ruby/std_vectora.i
index 1708361..1708361 100644
--- a/share/swig/2.0.11/ruby/std_vectora.i
+++ b/share/swig/3.0.12/ruby/std_vectora.i
diff --git a/share/swig/2.0.11/ruby/std_wstring.i b/share/swig/3.0.12/ruby/std_wstring.i
index 5ca77c0..5ca77c0 100644
--- a/share/swig/2.0.11/ruby/std_wstring.i
+++ b/share/swig/3.0.12/ruby/std_wstring.i
diff --git a/share/swig/3.0.12/ruby/stl.i b/share/swig/3.0.12/ruby/stl.i
new file mode 100644
index 0000000..9d2e91e
--- /dev/null
+++ b/share/swig/3.0.12/ruby/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/ruby/timeval.i b/share/swig/3.0.12/ruby/timeval.i
index e7bc2d3..e7bc2d3 100644
--- a/share/swig/2.0.11/ruby/timeval.i
+++ b/share/swig/3.0.12/ruby/timeval.i
diff --git a/share/swig/2.0.11/ruby/typemaps.i b/share/swig/3.0.12/ruby/typemaps.i
index c4db821..c4db821 100644
--- a/share/swig/2.0.11/ruby/typemaps.i
+++ b/share/swig/3.0.12/ruby/typemaps.i
diff --git a/share/swig/2.0.11/runtime.swg b/share/swig/3.0.12/runtime.swg
index 1528a52..1528a52 100644
--- a/share/swig/2.0.11/runtime.swg
+++ b/share/swig/3.0.12/runtime.swg
diff --git a/share/swig/3.0.12/scilab/boost_shared_ptr.i b/share/swig/3.0.12/scilab/boost_shared_ptr.i
new file mode 100644
index 0000000..b90422a
--- /dev/null
+++ b/share/swig/3.0.12/scilab/boost_shared_ptr.i
@@ -0,0 +1,320 @@
+%include <shared_ptr.i>
+
+// Set SHARED_PTR_DISOWN to $disown if required, for example
+// #define SHARED_PTR_DISOWN $disown
+#if !defined(SHARED_PTR_DISOWN)
+#define SHARED_PTR_DISOWN 0
+#endif
+
+// Language specific macro implementing all the customisations for handling the smart pointer
+%define SWIG_SHARED_PTR_TYPEMAPS(CONST, TYPE...)
+
+// %naturalvar is as documented for member variables
+%naturalvar TYPE;
+%naturalvar SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
+
+// destructor wrapper customisation
+%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) CONST TYPE (void *argp, int res = 0) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (!argp) {
+    %argument_nullref("$type", $symname, $argnum);
+  } else {
+    $1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
+    if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+  }
+}
+%typemap(out) CONST TYPE {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) CONST TYPE {
+  void *argp = 0;
+  int newmem = 0;
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  if (!argp) {
+    %variable_nullref("$type", "$name");
+  } else {
+    $1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
+    if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+  }
+}
+%typemap(varout) CONST TYPE {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+// plain pointer
+// Note: $disown not implemented by default as it will lead to a memory leak of the shared_ptr instance
+%typemap(in) CONST TYPE * (void  *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SHARED_PTR_DISOWN | %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast(tempshared.get(), $1_ltype);
+  } else {
+    smartarg = %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
+  }
+}
+
+%typemap(out, fragment="SWIG_null_deleter_python") CONST TYPE * {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), $owner | SWIG_POINTER_OWN));
+}
+
+%typemap(varin) CONST TYPE * {
+  void *argp = 0;
+  int newmem = 0;
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0;
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast(tempshared.get(), $1_ltype);
+  } else {
+    smartarg = %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
+  }
+}
+%typemap(varout, fragment="SWIG_null_deleter_python") CONST TYPE * {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_0) : 0;
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+// plain reference
+%typemap(in) CONST TYPE & (void  *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (!argp) { %argument_nullref("$type", $symname, $argnum); }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = %const_cast(tempshared.get(), $1_ltype);
+  } else {
+    $1 = %const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
+  }
+}
+%typemap(out, fragment="SWIG_null_deleter_python") CONST TYPE & {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner);
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) CONST TYPE & {
+  void *argp = 0;
+  int newmem = 0;
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
+  if (!argp) {
+    %variable_nullref("$type", "$name");
+  }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    $1 = *%const_cast(tempshared.get(), $1_ltype);
+  } else {
+    $1 = *%const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
+  }
+}
+%typemap(varout, fragment="SWIG_null_deleter_python") CONST TYPE & {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(&$1 SWIG_NO_NULL_DELETER_0);
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+// plain pointer by reference
+// Note: $disown not implemented by default as it will lead to a memory leak of the shared_ptr instance
+%typemap(in) TYPE *CONST& (void  *argp = 0, int res = 0, $*1_ltype temp = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SHARED_PTR_DISOWN | %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+    temp = %const_cast(tempshared.get(), $*1_ltype);
+  } else {
+    temp = %const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $*1_ltype);
+  }
+  $1 = &temp;
+}
+%typemap(out, fragment="SWIG_null_deleter_python") TYPE *CONST& {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1 SWIG_NO_NULL_DELETER_$owner);
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) TYPE *CONST& %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) TYPE *CONST& %{
+#error "varout typemap not implemented"
+%}
+
+// shared_ptr by value
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > (void *argp, int res = 0) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (argp) $1 = *(%reinterpret_cast(argp, $&ltype));
+  if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $&ltype);
+}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
+  int newmem = 0;
+  void *argp = 0;
+  int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  $1 = argp ? *(%reinterpret_cast(argp, $&ltype)) : SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE >();
+  if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $&ltype);
+}
+%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+// shared_ptr by reference
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & (void *argp, int res = 0, $*1_ltype tempshared) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
+    delete %reinterpret_cast(argp, $ltype);
+    $1 = &tempshared;
+  } else {
+    $1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
+  }
+}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
+#error "varout typemap not implemented"
+%}
+
+// shared_ptr by pointer
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * (void *argp, int res = 0, $*1_ltype tempshared) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (newmem & SWIG_CAST_NEW_MEMORY) {
+    if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
+    delete %reinterpret_cast(argp, $ltype);
+    $1 = &tempshared;
+  } else {
+    $1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
+  }
+}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 && *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+  if ($owner) delete $1;
+}
+
+%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
+#error "varout typemap not implemented"
+%}
+
+// shared_ptr by pointer reference
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& (void *argp, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, $*1_ltype temp = 0) {
+  int newmem = 0;
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (argp) tempshared = *%reinterpret_cast(argp, $*ltype);
+  if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $*ltype);
+  temp = &tempshared;
+  $1 = &temp;
+}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 && **$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(**$1) : 0;
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+}
+
+%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
+#error "varin typemap not implemented"
+%}
+%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
+#error "varout typemap not implemented"
+%}
+
+// Typecheck typemaps
+// Note: SWIG_ConvertPtr with void ** parameter set to 0 instead of using SWIG_ConvertPtrAndOwn, so that the casting 
+// function is not called thereby avoiding a possible smart pointer copy constructor call when casting up the inheritance chain.
+%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1) 
+                      TYPE CONST,
+                      TYPE CONST &,
+                      TYPE CONST *,
+                      TYPE *CONST&,
+                      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 > *& {
+  int res = SWIG_ConvertPtr($input, 0, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), 0);
+  $1 = SWIG_CheckState(res);
+}
+
+
+// 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"
+%}
+
+
+%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
+
+
+%enddef
+
diff --git a/share/swig/3.0.12/scilab/carrays.i b/share/swig/3.0.12/scilab/carrays.i
new file mode 100644
index 0000000..014de37
--- /dev/null
+++ b/share/swig/3.0.12/scilab/carrays.i
@@ -0,0 +1,5 @@
+%define %array_class(TYPE,NAME)
+  %array_class_wrap(TYPE,NAME,__paren__,__paren_asgn__)
+%enddef
+
+%include <typemaps/carrays.swg>
diff --git a/share/swig/2.0.11/tcl/cmalloc.i b/share/swig/3.0.12/scilab/cmalloc.i
index 248f06b..248f06b 100644
--- a/share/swig/2.0.11/tcl/cmalloc.i
+++ b/share/swig/3.0.12/scilab/cmalloc.i
diff --git a/share/swig/2.0.11/tcl/cpointer.i b/share/swig/3.0.12/scilab/cpointer.i
index d824792..d824792 100644
--- a/share/swig/2.0.11/tcl/cpointer.i
+++ b/share/swig/3.0.12/scilab/cpointer.i
diff --git a/share/swig/3.0.12/scilab/exception.i b/share/swig/3.0.12/scilab/exception.i
new file mode 100644
index 0000000..17f4175
--- /dev/null
+++ b/share/swig/3.0.12/scilab/exception.i
@@ -0,0 +1,6 @@
+%include <typemaps/exception.swg>
+
+
+%insert("runtime") {
+  %define_as(SWIG_exception(code, msg), SWIG_Scilab_Error(code, msg);)
+}
diff --git a/share/swig/3.0.12/scilab/matrix.i b/share/swig/3.0.12/scilab/matrix.i
new file mode 100644
index 0000000..0936d93
--- /dev/null
+++ b/share/swig/3.0.12/scilab/matrix.i
@@ -0,0 +1,11 @@
+/*
+ * Matrix typemaps
+ *
+ */
+
+%include <scimatrixdouble.swg>
+%include <scimatrixint.swg>
+%include <scimatrixchar.swg>
+%include <scimatrixbool.swg>
+
+
diff --git a/share/swig/3.0.12/scilab/sciarray.swg b/share/swig/3.0.12/scilab/sciarray.swg
new file mode 100644
index 0000000..c00e383
--- /dev/null
+++ b/share/swig/3.0.12/scilab/sciarray.swg
@@ -0,0 +1,115 @@
+/* --------------------------------------------------------------------------
+ *
+ *  Arrays typemaps
+ *
+ * --------------------------------------------------------------------------*/
+
+%{
+#include <stdio.h>
+%}
+
+%define %scilab_asarray_withallocatecopy(TYPEMAPTYPE, FRAGMENTNAME, CTYPE, TEMPDATATYPE)
+%typemap(TYPEMAPTYPE, fragment="FRAGMENTNAME") CTYPE {
+  size_t i = 0;
+  int iRows = 0;
+  int iCols = 0;
+  TEMPDATATYPE *pTempData = NULL;
+  if (FRAGMENTNAME(pvApiCtx, $input, &iRows, &iCols, &pTempData, fname)) {
+    return SWIG_ERROR;
+  }
+  $1 = ($1_ltype)MALLOC(sizeof($*1_ltype) * iRows * iCols);
+  for (i = 0; i < iRows * iCols; i++) {
+    $1[i] = ($*1_ltype) pTempData[i];
+  }
+}
+%enddef
+
+%define %scilab_asarrayandsize_withcopy(TYPEMAPTYPE, FRAGMENTNAME, CTYPE, TEMPDATATYPE)
+%typemap(TYPEMAPTYPE, fragment="FRAGMENTNAME") CTYPE {
+  int iRows = 0;
+  int iCols = 0;
+  TEMPDATATYPE *pTempData = NULL;
+  if (FRAGMENTNAME(pvApiCtx, $input, &iRows, &iCols, &pTempData, fname)) {
+    return SWIG_ERROR;
+  }
+  if (iRows*iCols <= $1_dim0) {
+    size_t i;
+    for (i = 0; i < $1_dim0; i++) {
+      $1[i] = ($*1_ltype) pTempData[i];
+    }
+  }
+  else {
+    char errmsg[100];
+    sprintf(errmsg, "Size of input data (%d) is too big (maximum is %d)",
+      iRows*iCols, $1_dim0);
+    SWIG_exception_fail(SWIG_OverflowError, errmsg);
+  }
+}
+%enddef
+
+%define %scilab_fromarrayandsize(TYPEMAPTYPE, FRAGMENTNAME, CTYPE)
+%typemap(TYPEMAPTYPE, noblock=1, fragment="FRAGMENTNAME") CTYPE {
+  %set_output(FRAGMENTNAME(pvApiCtx, $result, 1, $1_dim0, $1));
+}
+%enddef
+
+%define %scilab_array_typemaps(CTYPE, ASARRAY_FRAGMENT, FROMARRAY_FRAGMENT, TEMPDATATYPE)
+  %scilab_asarrayandsize_withcopy(varin, ASARRAY_FRAGMENT, CTYPE[ANY], TEMPDATATYPE);
+  %scilab_asarray_withallocatecopy(in, ASARRAY_FRAGMENT, CTYPE[ANY], TEMPDATATYPE);
+  %scilab_fromarrayandsize(varout, FROMARRAY_FRAGMENT, CTYPE[ANY]);
+  %scilab_fromarrayandsize(out, FROMARRAY_FRAGMENT, CTYPE[ANY]);
+
+  %apply SWIGTYPE[] { CTYPE[] };
+  %scilab_asarray_withallocatecopy(in, ASARRAY_FRAGMENT, CTYPE[], TEMPDATATYPE);
+%enddef
+
+
+// Double
+%scilab_array_typemaps(double, SWIG_SciDouble_AsDoubleArrayAndSize,
+  SWIG_SciDouble_FromDoubleArrayAndSize, double);
+
+// Signed char
+
+%scilab_array_typemaps(signed char, SWIG_SciDoubleOrInt8_AsSignedCharArrayAndSize,
+  SWIG_SciDouble_FromSignedCharArrayAndSize, signed char);
+
+// Unsigned char
+%scilab_array_typemaps(unsigned char, SWIG_SciDoubleOrUint8_AsUnsignedCharArrayAndSize,
+  SWIG_SciDouble_FromUnsignedCharArrayAndSize, unsigned char);
+
+// Short
+%scilab_array_typemaps(short, SWIG_SciDoubleOrInt16_AsShortArrayAndSize,
+  SWIG_SciDouble_FromShortArrayAndSize, short);
+
+// Unsigned short
+%scilab_array_typemaps(unsigned short, SWIG_SciDoubleOrUint16_AsUnsignedShortArrayAndSize,
+  SWIG_SciDouble_FromUnsignedShortArrayAndSize, unsigned short);
+
+// Int
+%scilab_array_typemaps(int, SWIG_SciDoubleOrInt32_AsIntArrayAndSize,
+  SWIG_SciDouble_FromIntArrayAndSize, int);
+
+// Unsigned int
+%scilab_array_typemaps(unsigned int, SWIG_SciDoubleOrUint32_AsUnsignedIntArrayAndSize,
+  SWIG_SciDouble_FromUnsignedIntArrayAndSize, unsigned int);
+
+// Long
+%scilab_array_typemaps(long, SWIG_SciDoubleOrInt32_AsIntArrayAndSize,
+  SWIG_SciDouble_FromLongArrayAndSize, int);
+
+// Unsigned long
+%scilab_array_typemaps(unsigned long, SWIG_SciDoubleOrUint32_AsUnsignedIntArrayAndSize,
+  SWIG_SciDouble_FromUnsignedLongArrayAndSize, unsigned int);
+
+// Float
+%scilab_array_typemaps(float, SWIG_SciDouble_AsFloatArrayAndSize,
+  SWIG_SciDouble_FromFloatArrayAndSize, float);
+
+// Bool
+%scilab_array_typemaps(bool, SWIG_SciBoolean_AsIntArrayAndSize,
+  SWIG_SciBoolean_FromBoolArrayAndSize, int);
+
+// Char *
+%scilab_array_typemaps(char *, SWIG_SciString_AsCharPtrArrayAndSize,
+  SWIG_SciString_FromCharPtrArrayAndSize, char *);
+
diff --git a/share/swig/3.0.12/scilab/scibool.swg b/share/swig/3.0.12/scilab/scibool.swg
new file mode 100644
index 0000000..9aed88e
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scibool.swg
@@ -0,0 +1,156 @@
+/*
+ * C-type: bool
+ * Scilab type: boolean scalar
+ */
+%fragment(SWIG_AsVal_frag(bool), "header") {
+SWIGINTERN int
+SWIG_AsVal_dec(bool)(SwigSciObject iVar, bool *pbValue) {
+  SciErr sciErr;
+  int iRet = 0;
+  int *piAddrVar = NULL;
+  int iTempValue = 0;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (!isBooleanType(pvApiCtx, piAddrVar)) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), SWIG_Scilab_GetFuncName(), iVar);
+    return SWIG_ERROR;
+  }
+
+  if (!isScalar(pvApiCtx, piAddrVar)) {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), SWIG_Scilab_GetFuncName(), iVar);
+    return SWIG_ERROR;
+  }
+
+  iRet = getScalarBoolean(pvApiCtx, piAddrVar, &iTempValue);
+  if (iRet) {
+    return SWIG_ERROR;
+  }
+
+  *pbValue = iTempValue;
+
+  return SWIG_OK;
+}
+}
+
+%fragment(SWIG_From_frag(bool), "header") {
+SWIGINTERN int
+SWIG_From_dec(bool)(bool bValue) {
+  if (createScalarBoolean(pvApiCtx, SWIG_NbInputArgument(pvApiCtx)
+    + SWIG_Scilab_GetOutputPosition(), bValue))
+    return SWIG_ERROR;
+  return SWIG_OK;
+}
+}
+
+/*
+ * C-type: bool[]
+ * Scilab type: boolean matrix
+ */
+%fragment("SWIG_SciBoolean_AsBoolArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciBoolean_AsBoolArrayAndSize(void *pvApiCtx, int iVar, int *iRows, int *iCols, bool **pbValue, char *fname) {
+  SciErr sciErr;
+  int *piAddrVar = NULL;
+  int *piValue = NULL;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (isBooleanType(pvApiCtx, piAddrVar)) {
+    int i;
+    sciErr = getMatrixOfBoolean(pvApiCtx, piAddrVar, iRows, iCols, &piValue);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+
+    *pbValue = (bool*) malloc((*iRows) * (*iCols) * sizeof(bool));
+    for (i = 0; i < (*iRows) * (*iCols); i++)
+      (*pbValue)[i] = piValue[i] != 0;
+  }
+  else {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A boolean matrix expected.\n"), fname, iVar);
+    return SWIG_ERROR;
+  }
+
+  return SWIG_OK;
+}
+}
+
+%fragment("SWIG_SciBoolean_FromBoolArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciBoolean_FromBoolArrayAndSize(void *pvApiCtx, int iVarOut, int iRows, int iCols, bool *pbValue) {
+  SciErr sciErr;
+  int *piValue = NULL;
+  int i;
+
+  piValue = (int*) malloc(iRows * iCols * sizeof(int));
+  for (i = 0; i < iRows * iCols; i++)
+    piValue[i] = pbValue[i];
+
+  sciErr = createMatrixOfBoolean(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, iRows, iCols, piValue);
+  if(sciErr.iErr) {
+    printError(&sciErr, 0);
+    free(piValue);
+    return SWIG_ERROR;
+  }
+
+  free(piValue);
+  return SWIG_OK;
+}
+}
+
+/*
+ * C-type: int[]
+ * Scilab type: boolean matrix
+ */
+%fragment("SWIG_SciBoolean_AsIntArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciBoolean_AsIntArrayAndSize(void *pvApiCtx, int iVar, int *iRows, int *iCols, int **piValue, char *fname) {
+  SciErr sciErr;
+  int *piAddrVar = NULL;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (isBooleanType(pvApiCtx, piAddrVar)) {
+    sciErr = getMatrixOfBoolean(pvApiCtx, piAddrVar, iRows, iCols, piValue);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+  }
+  else {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A boolean matrix expected.\n"), fname, iVar);
+    return SWIG_ERROR;
+  }
+
+  return SWIG_OK;
+}
+}
+
+%fragment("SWIG_SciBoolean_FromIntArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciBoolean_FromIntArrayAndSize(void *pvApiCtx, int iVarOut, int iRows, int iCols, int *piValue) {
+  SciErr sciErr;
+
+  sciErr = createMatrixOfBoolean(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, iRows, iCols, piValue);
+  if(sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  return SWIG_OK;
+}
+}
diff --git a/share/swig/3.0.12/scilab/scichar.swg b/share/swig/3.0.12/scilab/scichar.swg
new file mode 100644
index 0000000..5edbf5b
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scichar.swg
@@ -0,0 +1,292 @@
+/*
+ * C-type: char or char*
+ * Scilab type: string
+ */
+
+/*
+ * CHAR
+ */
+
+%fragment(SWIG_AsVal_frag(char), "header", fragment="SWIG_SciString_AsChar") {
+#define SWIG_AsVal_char(scilabValue, valuePointer) SWIG_SciString_AsChar(pvApiCtx, scilabValue, valuePointer, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_SciString_AsChar", "header") {
+SWIGINTERN int
+SWIG_SciString_AsChar(void *pvApiCtx, int iVar, char *pcValue, char *fname) {
+  SciErr sciErr;
+  int *piAddrVar = NULL;
+  char *pstValue = NULL;
+  int iRet;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (isStringType(pvApiCtx, piAddrVar) == 0)
+  {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A single string expected.\n"), fname, iVar);
+      return SWIG_TypeError;
+  }
+
+  iRet = getAllocatedSingleString(pvApiCtx, piAddrVar, &pstValue);
+  if (iRet) {
+    return SWIG_ERROR;
+  }
+
+  if (pcValue != NULL) {
+    *pcValue = pstValue[0];
+  }
+
+  freeAllocatedSingleString(pstValue);
+  return SWIG_OK;
+}
+}
+
+%fragment(SWIG_From_frag(char), "header", fragment="SWIG_SciString_FromChar") {
+#define SWIG_From_char(value) SWIG_SciString_FromChar(pvApiCtx, SWIG_Scilab_GetOutputPosition(), value)
+}
+%fragment("SWIG_SciString_FromChar", "header") {
+SWIGINTERN int
+SWIG_SciString_FromChar(void *pvApiCtx, int iVarOut, char chValue) {
+  char *pchValue = (char*)malloc(sizeof(char) * 2);
+  pchValue[0] = chValue;
+  pchValue[1] = '\0';
+
+  if (createSingleString(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, pchValue))
+    return SWIG_ERROR;
+
+  free(pchValue);
+  return SWIG_OK;
+}
+}
+
+/*
+ * CHAR *
+*/
+
+%fragment("SWIG_AsCharArray", "header", fragment = "SWIG_SciString_AsCharPtr") {
+#define SWIG_AsCharArray(scilabValue, charPtrPointer, charPtrLength) SWIG_SciString_AsCharPtr(pvApiCtx, scilabValue, charPtrPointer, charPtrLength, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_SciString_AsCharPtr", "header") {
+SWIGINTERN int
+SWIG_SciString_AsCharPtr(void *pvApiCtx, int iVar, char *pcValue, int iLength, char *fname) {
+  SciErr sciErr;
+  int *piAddrVar = NULL;
+  char* pcTmpValue = NULL;
+  int iRet;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  iRet = getAllocatedSingleString(pvApiCtx, piAddrVar, &pcTmpValue);
+  if (iRet) {
+    return SWIG_ERROR;
+  }
+
+  if (pcValue != NULL) {
+    strncpy(pcValue, pcTmpValue, iLength);
+  }
+
+  freeAllocatedSingleString(pcTmpValue);
+  return SWIG_OK;
+}
+}
+
+%fragment("SWIG_AsCharPtrAndSize", "header", fragment = "SWIG_SciString_AsCharPtrAndSize") {
+#define SWIG_AsCharPtrAndSize(scilabValue, charPtrPointer, charPtrLength, allocMemory) SWIG_SciString_AsCharPtrAndSize(pvApiCtx, scilabValue, charPtrPointer, charPtrLength, allocMemory, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_SciString_AsCharPtrAndSize", "header") {
+SWIGINTERN int
+SWIG_SciString_AsCharPtrAndSize(void *pvApiCtx, int iVar, char **pcValue, size_t *piLength, int *alloc, char *fname) {
+  SciErr sciErr;
+  int *piAddrVar = NULL;
+  char *pstString = NULL;
+  int iRows = 0;
+  int iCols = 0;
+  int iLen = 0;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (isScalar(pvApiCtx, piAddrVar) == 0 || isStringType(pvApiCtx, piAddrVar) == 0)
+  {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A single string expected.\n"), fname, iVar);
+      return SWIG_TypeError;
+  }
+
+  sciErr = getMatrixOfString(pvApiCtx, piAddrVar, &iRows, &iCols, &iLen, NULL);
+  if (sciErr.iErr)
+  {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+  }
+
+  pstString = %new_array(iLen + 1, char);
+
+  sciErr = getMatrixOfString(pvApiCtx, piAddrVar, &iRows, &iCols, &iLen, &pstString);
+  if (sciErr.iErr)
+  {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+  }
+
+  // TODO: return SWIG_ERROR if pcValue NULL (now returning SWIG_ERROR fails some typechecks)
+  if (pcValue) {
+    *pcValue = pstString;
+  }
+
+  if (alloc != NULL) {
+    *alloc = SWIG_NEWOBJ;
+  }
+
+  if (piLength != NULL) {
+    *piLength = strlen(pstString);
+  }
+
+  return SWIG_OK;
+}
+}
+
+%fragment("SWIG_FromCharPtr", "header", fragment = "SWIG_SciString_FromCharPtr") {
+#define SWIG_FromCharPtr(charPtr) SWIG_SciString_FromCharPtr(pvApiCtx, SWIG_Scilab_GetOutputPosition(), charPtr)
+}
+%fragment("SWIG_SciString_FromCharPtr", "header") {
+SWIGINTERN int
+SWIG_SciString_FromCharPtr(void *pvApiCtx, int iVarOut, const char *pchValue) {
+  if (pchValue) {
+    SciErr sciErr;
+    const char* pstStrings[1];
+    pstStrings[0] = pchValue;
+
+    sciErr = createMatrixOfString(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, 1, 1, pstStrings);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+  }
+  else {
+    int iRet = createEmptyMatrix(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut);
+    if (iRet) {
+      return SWIG_ERROR;
+    }
+  }
+
+  return SWIG_OK;
+}
+}
+
+/*
+ * CHAR * ARRAY
+ */
+
+%fragment("SWIG_SciString_AsCharPtrArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciString_AsCharPtrArrayAndSize(void *pvApiCtx, int iVar, int *iRows, int *iCols, char ***charPtrArray, char *fname) {
+  SciErr sciErr;
+  int i = 0;
+  int *piAddrVar = NULL;
+  int* piLength = NULL;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  sciErr = getMatrixOfString(pvApiCtx, piAddrVar, iRows, iCols, NULL, NULL);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  piLength = (int*) malloc((*iRows) * (*iCols) * sizeof(int));
+
+  sciErr = getMatrixOfString(pvApiCtx, piAddrVar, iRows, iCols, piLength, NULL);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  *charPtrArray = (char**) malloc((*iRows) * (*iCols) * sizeof(char*));
+  for(i = 0 ; i < (*iRows) * (*iCols); i++) {
+    (*charPtrArray)[i] = (char*) malloc(sizeof(char) * (piLength[i] + 1));
+  }
+
+  sciErr = getMatrixOfString(pvApiCtx, piAddrVar, iRows, iCols, piLength, *charPtrArray);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  free(piLength);
+  return SWIG_OK;
+}
+}
+
+%fragment("SWIG_SciString_FromCharPtrArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciString_FromCharPtrArrayAndSize(void *pvApiCtx, int iVarOut, int iRows, int iCols, char **charPtrArray) {
+  SciErr sciErr;
+
+  sciErr = createMatrixOfString(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, iRows, iCols, (const char* const*) charPtrArray);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  return SWIG_OK;
+}
+}
+
+%fragment("SWIG_FromCharPtrAndSize", "header", fragment = "SWIG_SciString_FromCharPtr") {
+#define SWIG_FromCharPtrAndSize(charPtr, charPtrLength) SWIG_SciString_FromCharPtr(pvApiCtx, SWIG_Scilab_GetOutputPosition(), charPtr)
+}
+
+
+/*
+ * Char* Scilab variable
+ */
+
+%fragment(SWIG_CreateScilabVariable_frag(char), "wrapper") {
+SWIGINTERN int
+SWIG_CreateScilabVariable_dec(char)(void *pvApiCtx, const char* psVariableName, const char cVariableValue) {
+  SciErr sciErr;
+  char sValue[2];
+  const char* psStrings[1];
+
+  sValue[0] = cVariableValue;
+  sValue[1] = '\0';
+  psStrings[0] = sValue;
+
+  sciErr = createNamedMatrixOfString(pvApiCtx, psVariableName, 1, 1, psStrings);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+  return SWIG_OK;
+}
+}
+
+%fragment(SWIG_CreateScilabVariable_frag(charptr), "wrapper") {
+SWIGINTERN int
+SWIG_CreateScilabVariable_dec(charptr)(void *pvApiCtx, const char* psVariableName, const char* psVariableValue) {
+  SciErr sciErr;
+  const char* psStrings[1];
+  psStrings[0] = psVariableValue;
+
+  sciErr = createNamedMatrixOfString(pvApiCtx, psVariableName, 1, 1, psStrings);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+  return SWIG_OK;
+}
+}
diff --git a/share/swig/3.0.12/scilab/scicontainer.swg b/share/swig/3.0.12/scilab/scicontainer.swg
new file mode 100644
index 0000000..2cc44b8
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scicontainer.swg
@@ -0,0 +1,444 @@
+/* -----------------------------------------------------------------------------
+ * scicontainer.swg
+ *
+ * Scilab list <-> C++ container wrapper
+ *
+ * This wrapper, and its iterator, allows a general use (and reuse) of
+ * the mapping between C++ and Scilab, thanks to the C++ templates.
+ *
+ * Of course, it needs the C++ compiler to support templates, but
+ * since we will use this wrapper with the STL containers, that should
+ * be the case.
+ * ----------------------------------------------------------------------------- */
+
+%{
+#include <iostream>
+%}
+
+#if !defined(SWIG_NO_EXPORT_ITERATOR_METHODS)
+# if !defined(SWIG_EXPORT_ITERATOR_METHODS)
+#  define SWIG_EXPORT_ITERATOR_METHODS SWIG_EXPORT_ITERATOR_METHODS
+# endif
+#endif
+
+
+// #define (SWIG_SCILAB_EXTRA_NATIVE_CONTAINERS)
+// if defined: sequences in return are converted from/to Scilab lists or matrices
+// if not defined: sequences are passed from/to Scilab as pointers
+
+%{
+#define SWIG_STD_NOASSIGN_STL
+%}
+
+%include <sciiterators.swg>
+%include <scisequence.swg>
+
+%{
+#include <stdexcept>
+%}
+
+%include <exception.i>
+%include <std_except.i>
+
+%fragment("SciSequence_Cont", "header",
+	  fragment="StdTraits",
+	  fragment="SwigSciIterator_T")
+{
+namespace swig
+{
+  template <class T>
+  struct SciSequence_Ref
+  {
+    SciSequence_Ref(const SwigSciObject& seq, int index)
+      : _seq(seq), _index(index)
+    {
+      if (traits_as_sequence<T>::get(_seq, &piSeqAddr) != SWIG_OK)
+      {
+        throw std::invalid_argument("Cannot get sequence data.");
+      }
+    }
+
+    operator T () const
+    {
+      return traits_asval_sequenceitem<T>::asval(_seq, piSeqAddr, _index);
+    }
+
+    SciSequence_Ref& operator=(const T& v)
+    {
+      // TODO
+      return *this;
+    }
+
+    private:
+      SwigSciObject _seq;
+      int _index;
+      void *piSeqAddr;
+  };
+
+
+  template <class T>
+  struct SciSequence_ArrowProxy
+  {
+    SciSequence_ArrowProxy(const T& x): m_value(x) {}
+    const T* operator->() const { return &m_value; }
+    operator const T*() const { return &m_value; }
+    T m_value;
+  };
+
+  template <class T, class Reference >
+  struct SwigSciSequence_InputIterator
+  {
+    typedef SwigSciSequence_InputIterator<T, Reference > self;
+
+    typedef std::random_access_iterator_tag iterator_category;
+    typedef Reference reference;
+    typedef T value_type;
+    typedef T* pointer;
+    typedef int difference_type;
+
+    SwigSciSequence_InputIterator()
+    {
+    }
+
+    SwigSciSequence_InputIterator(const SwigSciObject& seq, int index)
+      : _seq(seq), _index(index)
+    {
+    }
+
+    reference operator*() const
+    {
+      return reference(_seq, _index);
+    }
+
+    SciSequence_ArrowProxy<T>
+    operator->() const {
+      return SciSequence_ArrowProxy<T>(operator*());
+    }
+
+    bool operator==(const self& ri) const
+    {
+      return (_index == ri._index);
+    }
+
+    bool operator!=(const self& ri) const
+    {
+      return !(operator==(ri));
+    }
+
+    self& operator ++ ()
+    {
+      ++_index;
+      return *this;
+    }
+
+    self& operator -- ()
+    {
+      --_index;
+      return *this;
+    }
+
+    self& operator += (difference_type n)
+    {
+      _index += n;
+      return *this;
+    }
+
+    self operator +(difference_type n) const
+    {
+      return self(_seq, _index + n);
+    }
+
+    self& operator -= (difference_type n)
+    {
+      _index -= n;
+      return *this;
+    }
+
+    self operator -(difference_type n) const
+    {
+      return self(_seq, _index - n);
+    }
+
+    difference_type operator - (const self& ri) const
+    {
+      return _index - ri._index;
+    }
+
+    bool operator < (const self& ri) const
+    {
+      return _index < ri._index;
+    }
+
+    reference
+    operator[](difference_type n) const
+    {
+      return reference(_seq, _index + n);
+    }
+
+  private:
+    SwigSciObject _seq;
+    difference_type _index;
+  };
+
+  template <class T>
+  struct SciSequence_Cont
+  {
+    typedef SciSequence_Ref<T> reference;
+    typedef const SciSequence_Ref<T> const_reference;
+    typedef T value_type;
+    typedef T* pointer;
+    typedef int difference_type;
+    typedef int size_type;
+    typedef const pointer const_pointer;
+    typedef SwigSciSequence_InputIterator<T, reference> iterator;
+    typedef SwigSciSequence_InputIterator<T, const_reference> const_iterator;
+
+    SciSequence_Cont(const SwigSciObject& seq) : _seq(seq)
+    {
+    }
+
+    ~SciSequence_Cont()
+    {
+    }
+
+    size_type size() const
+    {
+      int iSeqSize;
+      if (traits_as_sequence<value_type>::size(_seq, &iSeqSize) == SWIG_OK)
+      {
+        return iSeqSize;
+      }
+      else
+      {
+        return SWIG_ERROR;
+      }
+    }
+
+    bool empty() const
+    {
+      return size() == 0;
+    }
+
+    iterator begin()
+    {
+      return iterator(_seq, 0);
+    }
+
+    const_iterator begin() const
+    {
+      return const_iterator(_seq, 0);
+    }
+
+    iterator end()
+    {
+      return iterator(_seq, size());
+    }
+
+    const_iterator end() const
+    {
+      return const_iterator(_seq, size());
+    }
+
+    reference operator[](difference_type n)
+    {
+      return reference(_seq, n);
+    }
+
+    const_reference operator[](difference_type n)  const
+    {
+      return const_reference(_seq, n);
+    }
+
+  private:
+    SwigSciObject _seq;
+  };
+}
+}
+
+%define %swig_sequence_iterator(Sequence...)
+#if defined(SWIG_EXPORT_ITERATOR_METHODS)
+  class iterator;
+  class reverse_iterator;
+  class const_iterator;
+  class const_reverse_iterator;
+
+  %typemap(out,noblock=1,fragment="SciSequence_Cont")
+    iterator, reverse_iterator, const_iterator, const_reverse_iterator {
+    %set_output(SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &)),
+           swig::SciSwigIterator::descriptor(),SWIG_POINTER_OWN));
+  }
+  %typemap(out,fragment="SciSequence_Cont")
+    std::pair<iterator, iterator>, std::pair<const_iterator, const_iterator> {
+    // TODO: return a Scilab list from the pair (see code for Octave)
+  }
+
+  %fragment("SciSwigPairBoolOutputIterator", "header",
+    fragment=SWIG_From_frag(bool), fragment="SciSequence_Cont") {}
+
+  %typemap(out,fragment="SciSwigPairBoolOutputIterator")
+    std::pair<iterator, bool>, std::pair<const_iterator, bool> {
+    // TODO: return a Scilab list from the pair (see code for Octave)
+  }
+
+  %typemap(in,noblock=1,fragment="SciSequence_Cont")
+    iterator(swig::SciSwigIterator *iter = 0, int res),
+    reverse_iterator(swig::SciSwigIterator *iter = 0, int res),
+    const_iterator(swig::SciSwigIterator *iter = 0, int res),
+    const_reverse_iterator(swig::SciSwigIterator *iter = 0, int res) {
+    res = SWIG_ConvertPtr((SwigSciObject)$input, %as_voidptrptr(&iter), swig::SciSwigIterator::descriptor(), 0);
+    if (!SWIG_IsOK(res) || !iter) {
+      %argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
+    } else {
+      swig::SwigSciIterator_T<$type > *iter_t = dynamic_cast<swig::SwigSciIterator_T<$type > *>(iter);
+      if (iter_t) {
+	$1 = iter_t->get_current();
+      } else {
+	%argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
+      }
+    }
+  }
+
+  %typecheck(%checkcode(ITERATOR),noblock=1,fragment="SciSequence_Cont")
+    iterator, reverse_iterator, const_iterator, const_reverse_iterator {
+    swig::SciSwigIterator *iter = 0;
+    int res = SWIG_ConvertPtr((SwigSciObject)$input, %as_voidptrptr(&iter), swig::SciSwigIterator::descriptor(), 0);
+    $1 = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigSciIterator_T<$type > *>(iter) != 0));
+  }
+
+  %fragment("SciSequence_Cont");
+#endif //SWIG_EXPORT_ITERATOR_METHODS
+%enddef
+
+// The Scilab container methods
+
+%define %swig_container_methods(Container...)
+%enddef
+
+%define %swig_sequence_methods_common(Sequence...)
+  %swig_sequence_iterator(%arg(Sequence))
+  %swig_container_methods(%arg(Sequence))
+
+%enddef
+
+%define %swig_sequence_methods(Sequence...)
+  %swig_sequence_methods_common(%arg(Sequence))
+%enddef
+
+%define %swig_sequence_methods_val(Sequence...)
+  %swig_sequence_methods_common(%arg(Sequence))
+%enddef
+
+//
+// Common fragments
+//
+
+%fragment("StdSequenceTraits","header",
+	  fragment="StdTraits",
+	  fragment="SciSequence_Cont",
+    fragment=SWIG_Traits_SequenceItem_frag(ptr))
+{
+namespace swig {
+  template <class SciSeq, class Seq>
+  inline void
+  assign(const SciSeq& sciSeq, Seq* seq) {
+%#ifdef SWIG_STD_NOASSIGN_STL
+    typedef typename SciSeq::value_type value_type;
+    typename SciSeq::const_iterator it = sciSeq.begin();
+    for (;it != sciSeq.end(); ++it) {
+      seq->insert(seq->end(),(value_type)(*it));
+    }
+%#else
+    seq->assign(sciSeq.begin(), sciSeq.end());
+%#endif
+  }
+
+  template <class Seq, class T = typename Seq::value_type >
+  struct traits_asptr_stdseq {
+    typedef Seq sequence;
+    typedef T value_type;
+
+    static int asptr(const SwigSciObject& obj, sequence **seq)
+    {
+      swig_type_info *typeInfo = swig::type_info<sequence>();
+      if (typeInfo)
+      {
+          sequence *p;
+          if (SWIG_ConvertPtr(obj, (void**)&p, typeInfo, 0) == SWIG_OK)
+          {
+            if (seq)
+              *seq = p;
+            return SWIG_OLDOBJ;
+          }
+      }
+
+      if (traits_as_sequence<value_type>::check(obj) == SWIG_OK)
+      {
+        try
+        {
+          SciSequence_Cont<value_type> sciSeq(obj);
+          if (seq)
+          {
+            *seq = new sequence();
+            assign(sciSeq, *seq);
+            return SWIG_NEWOBJ;
+          }
+          else
+          {
+            return SWIG_ERROR;
+          }
+        }
+        catch (std::exception& e)
+        {
+          SWIG_exception(SWIG_RuntimeError, e.what());
+          return SWIG_ERROR;
+        }
+      }
+      else 
+      {
+        return SWIG_ERROR;
+      }
+    }
+  };
+
+  template <class Seq, class T = typename Seq::value_type >
+  struct traits_from_stdseq {
+    typedef Seq sequence;
+    typedef T value_type;
+    typedef typename Seq::size_type size_type;
+    typedef typename sequence::const_iterator const_iterator;
+
+    static SwigSciObject from(const sequence& seq)
+    {
+      %#ifdef SWIG_SCILAB_EXTRA_NATIVE_CONTAINERS
+      swig_type_info *typeInfo = swig::type_info<sequence>();
+      if (typeInfo)
+      {
+        return SWIG_NewPointerObj(new sequence(seq), typeInfo, SWIG_POINTER_OWN);
+      }
+      %#endif
+
+      try
+      {
+        void *data;
+        size_type size = seq.size();
+        if (traits_from_sequence<value_type>::create(size, &data) == SWIG_OK) {
+          const_iterator it;
+          int index = 0;
+          for (it = seq.begin(); it != seq.end(); ++it)
+          {
+            traits_from_sequenceitem<value_type>::from(data, index, *it);
+            index++;
+          }
+          return traits_from_sequence<value_type>::set(size, data);
+        }
+        return SWIG_OK;
+      }
+      catch (std::exception& e)
+      {
+        SWIG_exception(SWIG_RuntimeError, e.what());
+        return SWIG_ERROR;
+      }
+    }
+  };
+}
+}
diff --git a/share/swig/3.0.12/scilab/scidouble.swg b/share/swig/3.0.12/scilab/scidouble.swg
new file mode 100644
index 0000000..1b82633
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scidouble.swg
@@ -0,0 +1,108 @@
+/*
+ * DOUBLE SCALAR
+ */
+%fragment(SWIG_AsVal_frag(double), "header", fragment="SWIG_SciDouble_AsDouble") {
+%#define SWIG_AsVal_double(scilabValue, valuePointer) SWIG_SciDouble_AsDouble(pvApiCtx, scilabValue, valuePointer, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_SciDouble_AsDouble", "header") {
+SWIGINTERN int
+SWIG_SciDouble_AsDouble(void *pvApiCtx, SwigSciObject iVar, double *pdblValue, char *fname) {
+  SciErr sciErr;
+  int iRet = 0;
+  int *piAddrVar = NULL;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (!isDoubleType(pvApiCtx, piAddrVar) || isVarComplex(pvApiCtx, piAddrVar)) {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, iVar);
+    return SWIG_ERROR;
+  }
+
+  if (!isScalar(pvApiCtx, piAddrVar)) {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, iVar);
+    return SWIG_ERROR;
+  }
+
+  iRet = getScalarDouble(pvApiCtx, piAddrVar, pdblValue);
+  if (iRet) {
+    return SWIG_ERROR;
+  }
+
+  return SWIG_OK;
+}
+}
+
+%fragment(SWIG_From_frag(double), "header", fragment="SWIG_SciDouble_FromDouble") { 
+%#define SWIG_From_double(scilabValue) SWIG_SciDouble_FromDouble(pvApiCtx, SWIG_Scilab_GetOutputPosition(), scilabValue, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_SciDouble_FromDouble", "header") {
+SWIGINTERN int
+SWIG_SciDouble_FromDouble(void *pvApiCtx, int iVarOut, double dblValue, char *fname) {
+  if (createScalarDouble(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, dblValue))
+    return SWIG_ERROR;
+  return SWIG_OK;
+}
+}
+
+/*
+ * DOUBLE ARRAY
+ */
+
+%fragment("SWIG_SciDouble_AsDoubleArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciDouble_AsDoubleArrayAndSize(void *pvApiCtx, int iVar, int *iRows, int *iCols, double **pdValue, char *fname) {
+  SciErr sciErr;
+  int *piAddrVar = NULL;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (isDoubleType(pvApiCtx, piAddrVar) && !isVarComplex(pvApiCtx, piAddrVar)) {
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrVar, iRows, iCols, pdValue);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+  }
+  else {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), fname, iVar);
+    return SWIG_ERROR;
+  }
+
+  return SWIG_OK;
+}
+}
+
+%fragment("SWIG_SciDouble_FromDoubleArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciDouble_FromDoubleArrayAndSize(void *pvApiCtx, int iVarOut, int iRows, int iCols, double *pdblValue) {
+  SciErr sciErr;
+  sciErr = createMatrixOfDouble(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, iRows, iCols, pdblValue);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  return SWIG_OK;
+}
+}
+
+%fragment(SWIG_CreateScilabVariable_frag(double), "wrapper") {
+SWIGINTERN int
+SWIG_CreateScilabVariable_dec(double)(void *pvApiCtx, const char* psVariableName, const double dVariableValue) {
+  SciErr sciErr;
+  sciErr = createNamedMatrixOfDouble(pvApiCtx, psVariableName, 1, 1, &dVariableValue);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+  return SWIG_OK;
+}
+}
diff --git a/share/swig/3.0.12/scilab/scienum.swg b/share/swig/3.0.12/scilab/scienum.swg
new file mode 100644
index 0000000..54ec1f8
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scienum.swg
@@ -0,0 +1,31 @@
+/*
+ * C-type: enum
+ * Scilab type: double or int32
+ */
+
+%fragment(SWIG_AsVal_frag(Enum), "header", fragment="SWIG_Int_AsEnum") {
+%#define SWIG_AsVal_Enum(scilabValue, valuePointer) SWIG_Int_AsEnum(pvApiCtx, scilabValue, valuePointer, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_Int_AsEnum", "header", fragment="SWIG_SciDoubleOrInt32_AsInt") {
+SWIGINTERN int
+SWIG_Int_AsEnum(void *pvApiCtx, int iVar, int *enumValue, char *fname) {
+  int iValue = 0;
+  if (SWIG_SciDoubleOrInt32_AsInt(pvApiCtx, iVar, &iValue, fname) != SWIG_OK)
+    return SWIG_ERROR;
+  *enumValue = iValue;
+  return SWIG_OK;
+}
+}
+
+%fragment(SWIG_From_frag(Enum), "header", fragment="SWIG_Int_FromEnum") {
+%#define SWIG_From_Enum(scilabValue) SWIG_Int_FromEnum(pvApiCtx, SWIG_Scilab_GetOutputPosition(), scilabValue, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_Int_FromEnum", "header", fragment="SWIG_SciDouble_FromInt") {
+SWIGINTERN int
+SWIG_Int_FromEnum(void *pvApiCtx, int iVarOut, int enumValue, char *fname) {
+  if (SWIG_SciDouble_FromInt(pvApiCtx, iVarOut, enumValue, fname) != SWIG_OK)
+    return SWIG_ERROR;
+  SWIG_Scilab_SetOutput(pvApiCtx, iVarOut);
+  return SWIG_OK;
+}
+}
diff --git a/share/swig/3.0.12/scilab/sciexception.swg b/share/swig/3.0.12/scilab/sciexception.swg
new file mode 100644
index 0000000..a5eb4c0
--- /dev/null
+++ b/share/swig/3.0.12/scilab/sciexception.swg
@@ -0,0 +1,60 @@
+/*
+ * Exception typemaps (throws)
+ */
+
+%include <exception.i>
+
+%typemap(throws, noblock=1) int, unsigned int, signed int,
+                            int&,unsigned int&, signed int&,
+                            long, unsigned long, signed long,
+                            short, unsigned short,signed short,
+                            long long, unsigned long long,
+                            unsigned char, signed char,
+                            long&, unsigned long&, signed long&,
+                            short&, unsigned short&, signed short&,
+                            long long&, unsigned long long&,
+                            unsigned char&, signed char&,
+                            size_t, size_t&,
+                            ptrdiff_t, ptrdiff_t& {
+  char obj[20];
+  sprintf(obj, "%d", (int)$1);
+  SWIG_Scilab_Raise_Ex(obj, "$type", $descriptor);
+}
+
+%typemap(throws, noblock=1) enum SWIGTYPE {
+  char obj[20];
+  sprintf(obj, "%d", (int)$1);
+  SWIG_Scilab_Raise_Ex(obj, "$type", $descriptor);
+}
+
+%typemap(throws, noblock=1) float, double,
+                            float&, double& {
+  char obj[20];
+  sprintf(obj, "%5.3f", (double)$1);
+  SWIG_Scilab_Raise_Ex(obj, "$type", $descriptor);
+}
+
+%typemap(throws, noblock=1) bool, bool& {
+  SWIG_Scilab_Raise_Ex($1 ? "true" : "false", "$type", $descriptor);
+}
+
+%typemap(throws, noblock=1) char*, char[ANY] {
+  SWIG_Scilab_Raise_Ex($1, "$type", $descriptor);
+}
+
+%typemap(throws, noblock=1) char, char& {
+  char obj[1];
+  sprintf(obj, "%c", (char)$1);
+  SWIG_Scilab_Raise_Ex(obj, "$type", $descriptor);
+}
+
+%typemap(throws, noblock=1) SWIGTYPE,
+                            SWIGTYPE*,
+                            SWIGTYPE [ANY],
+                            SWIGTYPE & {
+  SWIG_Scilab_Raise_Ex((char*)NULL, "$type", $descriptor);
+}
+
+%typemap(throws, noblock=1) (...) {
+  SWIG_exception(SWIG_RuntimeError, "unknown exception");
+}
diff --git a/share/swig/3.0.12/scilab/scifloat.swg b/share/swig/3.0.12/scilab/scifloat.swg
new file mode 100644
index 0000000..f0af17c
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scifloat.swg
@@ -0,0 +1,83 @@
+/*
+ * FLOAT SCALAR
+ */
+
+%fragment(SWIG_AsVal_frag(float), "header", fragment=SWIG_AsVal_frag(double)) {
+SWIGINTERN int
+SWIG_AsVal_dec(float)(SwigSciObject iVar, float *pfValue) {
+  double dblValue = 0.0;
+  if(SWIG_AsVal_dec(double)(iVar, &dblValue) != SWIG_OK) {
+    return SWIG_ERROR;
+  }
+  if (pfValue)
+    *pfValue = (float) dblValue;
+  return SWIG_OK;
+}
+}
+
+%fragment(SWIG_From_frag(float), "header") {
+SWIGINTERN int
+SWIG_From_dec(float)(float flValue) {
+  if (createScalarDouble(pvApiCtx, SWIG_NbInputArgument(pvApiCtx)
+    + SWIG_Scilab_GetOutputPosition(), (double)flValue))
+    return SWIG_ERROR;
+  return SWIG_OK;
+}
+}
+
+%fragment("SWIG_SciDouble_AsFloatArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciDouble_AsFloatArrayAndSize(void *pvApiCtx, int iVar, int *iRows, int *iCols, float **pfValue, char *fname) {
+  SciErr sciErr;
+  int *piAddrVar = NULL;
+  double *pdValue = NULL;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (isDoubleType(pvApiCtx, piAddrVar) && !isVarComplex(pvApiCtx, piAddrVar)) {
+    int i;
+
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrVar, iRows, iCols, &pdValue);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+
+    *pfValue = (float *) malloc((*iRows) * (*iCols) * sizeof(float));
+    for (i=0; i < (*iRows) * (*iCols); i++)
+      (*pfValue)[i] = (float) pdValue[i];
+
+    return SWIG_OK;
+  }
+  else {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), fname, iVar);
+    return SWIG_ERROR;
+  }
+}
+}
+
+%fragment("SWIG_SciDouble_FromFloatArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciDouble_FromFloatArrayAndSize(void *pvApiCtx, int iVarOut, int iRows, int iCols, float *pfValue) {
+  SciErr sciErr;
+  double *pdValue;
+  int i;
+
+  pdValue = (double *) malloc(iRows * iCols * sizeof(double));
+  for (i = 0; i < iRows * iCols; i++)
+    pdValue[i] = pfValue[i];
+
+  sciErr = createMatrixOfDouble(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, iRows, iCols, pdValue);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  free(pdValue);
+  return SWIG_OK;
+}
+}
diff --git a/share/swig/3.0.12/scilab/sciint.swg b/share/swig/3.0.12/scilab/sciint.swg
new file mode 100644
index 0000000..2d69935
--- /dev/null
+++ b/share/swig/3.0.12/scilab/sciint.swg
@@ -0,0 +1,202 @@
+/*
+ * C-type: int
+ * Scilab type: double or int32
+ */
+
+%fragment(SWIG_AsVal_frag(int), "header", fragment="SWIG_SciDoubleOrInt32_AsInt", fragment="<limits.h>") {
+%#define SWIG_AsVal_int(scilabValue, valuePointer) SWIG_SciDoubleOrInt32_AsInt(pvApiCtx, scilabValue, valuePointer, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_SciDoubleOrInt32_AsInt", "header") {
+SWIGINTERN int
+SWIG_SciDoubleOrInt32_AsInt(void *pvApiCtx, SwigSciObject iVar, int *piValue, char *fname)
+{
+  SciErr sciErr;
+  int iType = 0;
+  int iRows = 0;
+  int iCols = 0;
+  int *piAddrVar = NULL;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  sciErr = getVarType(pvApiCtx, piAddrVar, &iType);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (iType == sci_ints) {
+    if (piValue) {
+      int iPrec = 0;
+      int *piData = NULL;
+
+      sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddrVar, &iPrec);
+      if (sciErr.iErr) {
+        printError(&sciErr, 0);
+        return SWIG_ERROR;
+      }
+      if (iPrec != SCI_INT32) {
+        Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 32-bit signed integer or a double expected.\n"), fname, iVar);
+        return SWIG_TypeError;
+      }
+      sciErr = getMatrixOfInteger32(pvApiCtx, piAddrVar, &iRows, &iCols, &piData);
+      if (sciErr.iErr) {
+        printError(&sciErr, 0);
+        return SWIG_ERROR;
+      }
+      if (iRows * iCols != 1) {
+        Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong size for input argument #%d: A 32-bit signed integer or a double expected.\n"), fname, iVar);
+        return SWIG_TypeError;
+      }
+      *piValue = *piData;
+    }
+  }
+  else if (iType == sci_matrix) {
+    if (piValue) {
+      double *pdData = NULL;
+      double dValue = 0.0f;
+      sciErr = getMatrixOfDouble(pvApiCtx, piAddrVar, &iRows, &iCols, &pdData);
+      if (sciErr.iErr) {
+        printError(&sciErr, 0);
+        return SWIG_ERROR;
+      }
+      if (iRows * iCols != 1) {
+        Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong size for input argument #%d: A 32-bit signed integer or a double expected.\n"), fname, iVar);
+        return SWIG_TypeError;
+      }
+      dValue = *pdData;
+      if (dValue != floor(dValue)) {
+        Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 32-bit signed integer.\n"), fname, iVar);
+        return SWIG_ValueError;
+      }
+      if ((dValue < INT_MIN) || (dValue > INT_MAX)) {
+        Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 32-bit signed integer.\n"), fname, iVar);
+        return SWIG_OverflowError;
+      }
+      *piValue = (int) dValue;
+    }
+  }
+  else {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 32-bit signed integer or a double expected.\n"), fname, iVar);
+    return SWIG_TypeError;
+  }
+
+  return SWIG_OK;
+}
+}
+
+%fragment(SWIG_From_frag(int), "header", fragment="SWIG_SciDouble_FromInt") {
+%#define SWIG_From_int(scilabValue) SWIG_SciDouble_FromInt(pvApiCtx, SWIG_Scilab_GetOutputPosition(), scilabValue, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_SciDouble_FromInt", "header") {
+SWIGINTERN int
+SWIG_SciDouble_FromInt(void *pvApiCtx, int iVarOut, int iValue, char *fname){
+  if (createScalarDouble(pvApiCtx, SWIG_NbInputArgument(pvApiCtx)
+    + iVarOut, (double) iValue))
+    return SWIG_ERROR;
+  return SWIG_OK;
+}
+}
+
+/*
+ * C-type: int[]
+ * Scilab type: double or int32 matrix
+ */
+%fragment("SWIG_SciDoubleOrInt32_AsIntArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciDoubleOrInt32_AsIntArrayAndSize(void *pvApiCtx, int iVar, int *iRows, int *iCols, int **piValue, char *fname) {
+  SciErr sciErr;
+  int iType = 0;
+  int *piAddrVar = NULL;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  sciErr = getVarType(pvApiCtx, piAddrVar, &iType);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (iType == sci_matrix) {
+    double *pdData = NULL;
+    int size = 0;
+    int i;
+
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrVar, iRows, iCols, &pdData);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+
+    size = (*iRows) * (*iCols);
+    *piValue = (int*) malloc(size * sizeof(int*));
+    for (i = 0; i < size; i++)
+      (*piValue)[i] = (int) pdData[i];
+  }
+  else if (iType == sci_ints) {
+    int iPrec = 0;
+    sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddrVar, &iPrec);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+    if (iPrec != SCI_INT32) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 32-bit signed integer or a double matrix expected.\n"), fname, iVar);
+      return SWIG_ERROR;
+    }
+    sciErr = getMatrixOfInteger32(pvApiCtx, piAddrVar, iRows, iCols, piValue);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+  }
+  else {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 32-bit signed integer or a double matrix expected.\n"), fname, iVar);
+    return SWIG_ERROR;
+  }
+  return SWIG_OK;
+}
+}
+
+%fragment("SWIG_SciDouble_FromIntArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciDouble_FromIntArrayAndSize(void *pvApiCtx, int iVarOut, int iRows, int iCols, const int *piData) {
+  SciErr sciErr;
+  double *pdValues = NULL;
+  int i;
+
+  pdValues = (double*) malloc(iRows * iCols * sizeof(double));
+  for (i=0; i<iRows * iCols; i++)
+    pdValues[i] = piData[i];
+
+  sciErr = createMatrixOfDouble(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, iRows, iCols, pdValues);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    free(pdValues);
+    return SWIG_ERROR;
+  }
+
+  free(pdValues);
+  return SWIG_OK;
+}
+}
+
+%fragment(SWIG_CreateScilabVariable_frag(int), "wrapper") {
+SWIGINTERN int
+SWIG_CreateScilabVariable_dec(int)(void *pvApiCtx, const char* psVariableName, const int iVariableValue) {
+  SciErr sciErr;
+  sciErr = createNamedMatrixOfInteger32(pvApiCtx, psVariableName, 1, 1, &iVariableValue);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+  return SWIG_OK;
+}
+}
diff --git a/share/swig/3.0.12/scilab/sciiterators.swg b/share/swig/3.0.12/scilab/sciiterators.swg
new file mode 100644
index 0000000..1c7ce43
--- /dev/null
+++ b/share/swig/3.0.12/scilab/sciiterators.swg
@@ -0,0 +1,363 @@
+/* -----------------------------------------------------------------------------
+ * sciiterators.swg
+ *
+ * Users can derive form the SciSwigIterator to implemet their
+ * own iterators. As an example (real one since we use it for STL/STD
+ * containers), the template SwigSciIterator_T does the
+ * implementation for generic C++ iterators.
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+
+%fragment("SciSwigIterator","header",fragment="<stddef.h>") {
+namespace swig {
+  struct stop_iteration {
+  };
+
+  struct SciSwigIterator {
+  private:
+    SwigSciObject _seq;
+
+  protected:
+    SciSwigIterator(SwigSciObject seq) : _seq(seq)
+    {
+    }
+
+  public:
+    virtual ~SciSwigIterator() {}
+
+    virtual SwigSciObject value() const = 0;
+
+    virtual SciSwigIterator *incr(size_t n = 1) = 0;
+
+    virtual SciSwigIterator *decr(size_t n = 1)
+    {
+      throw stop_iteration();
+    }
+
+    virtual ptrdiff_t distance(const SciSwigIterator &x) const
+    {
+      throw std::invalid_argument("operation not supported");
+    }
+
+    virtual bool equal (const SciSwigIterator &x) const
+    {
+      throw std::invalid_argument("operation not supported");
+    }
+
+    virtual SciSwigIterator *copy() const = 0;
+
+    SwigSciObject next()
+    {
+      SwigSciObject obj = value();
+      incr();
+      return obj;
+    }
+
+    SwigSciObject previous()
+    {
+      decr();
+      return value();
+    }
+
+    SciSwigIterator *advance(ptrdiff_t n)
+    {
+      return  (n > 0) ?  incr(n) : decr(-n);
+    }
+
+    bool operator == (const SciSwigIterator& x)  const
+    {
+      return equal(x);
+    }
+
+    bool operator != (const SciSwigIterator& x) const
+    {
+      return ! operator==(x);
+    }
+
+    SciSwigIterator* operator ++ () {
+      incr();
+      return this;
+    }
+
+    SciSwigIterator* operator -- () {
+      decr();
+      return this;
+    }
+
+    SciSwigIterator* operator + (ptrdiff_t n) const
+    {
+      return copy()->advance(n);
+    }
+
+    SciSwigIterator* operator - (ptrdiff_t n) const
+    {
+      return copy()->advance(-n);
+    }
+
+    ptrdiff_t operator - (const SciSwigIterator& x) const
+    {
+      return x.distance(*this);
+    }
+
+    static swig_type_info* descriptor() {
+      static int init = 0;
+      static swig_type_info* desc = 0;
+      if (!init) {
+	desc = SWIG_TypeQuery("swig::SciSwigIterator *");
+	init = 1;
+      }
+      return desc;
+    }
+  };
+}
+}
+
+%fragment("SwigSciIterator_T","header",fragment="<stddef.h>",fragment="SciSwigIterator",fragment="StdTraits",fragment="StdIteratorTraits") {
+namespace swig {
+  template<typename OutIterator>
+  class SwigSciIterator_T :  public SciSwigIterator
+  {
+  public:
+    typedef OutIterator out_iterator;
+    typedef typename std::iterator_traits<out_iterator>::value_type value_type;
+    typedef SwigSciIterator_T<out_iterator> self_type;
+
+    SwigSciIterator_T(out_iterator curr, SwigSciObject seq)
+      : SciSwigIterator(seq), current(curr)
+    {
+    }
+
+    const out_iterator& get_current() const
+    {
+      return current;
+    }
+
+
+    bool equal (const SciSwigIterator &iter) const
+    {
+      const self_type *iters = dynamic_cast<const self_type *>(&iter);
+      if (iters) {
+	return (current == iters->get_current());
+      } else {
+	throw std::invalid_argument("bad iterator type");
+      }
+    }
+
+    ptrdiff_t distance(const SciSwigIterator &iter) const
+    {
+      const self_type *iters = dynamic_cast<const self_type *>(&iter);
+      if (iters) {
+	return std::distance(current, iters->get_current());
+      } else {
+	throw std::invalid_argument("bad iterator type");
+      }
+    }
+
+  protected:
+    out_iterator current;
+  };
+
+  template <class ValueType>
+  struct from_oper
+  {
+    typedef const ValueType& argument_type;
+    typedef SwigSciObject result_type;
+    result_type operator()(argument_type v) const
+    {
+      return swig::from(v);
+    }
+  };
+
+  template<typename OutIterator,
+	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
+	   typename FromOper = from_oper<ValueType> >
+  class SciSwigIteratorOpen_T :  public SwigSciIterator_T<OutIterator>
+  {
+  public:
+    FromOper from;
+    typedef OutIterator out_iterator;
+    typedef ValueType value_type;
+    typedef SwigSciIterator_T<out_iterator>  base;
+    typedef SciSwigIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
+
+    SciSwigIteratorOpen_T(out_iterator curr, SwigSciObject seq)
+      : SwigSciIterator_T<OutIterator>(curr, seq)
+    {
+    }
+
+    SwigSciObject value() const {
+      return from(static_cast<const value_type&>(*(base::current)));
+    }
+
+    SciSwigIterator *copy() const
+    {
+      return new self_type(*this);
+    }
+
+    SciSwigIterator *incr(size_t n = 1)
+    {
+      while (n--) {
+	++base::current;
+      }
+      return this;
+    }
+
+    SciSwigIterator *decr(size_t n = 1)
+    {
+      while (n--) {
+	--base::current;
+      }
+      return this;
+    }
+  };
+
+  template<typename OutIterator,
+	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
+	   typename FromOper = from_oper<ValueType> >
+  class SciSwigIteratorClosed_T :  public SwigSciIterator_T<OutIterator>
+  {
+  public:
+    FromOper from;
+    typedef OutIterator out_iterator;
+    typedef ValueType value_type;
+    typedef SwigSciIterator_T<out_iterator>  base;
+    typedef SciSwigIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
+
+    SciSwigIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, SwigSciObject seq)
+      : SwigSciIterator_T<OutIterator>(curr, seq), begin(first), end(last)
+    {
+    }
+
+    SwigSciObject value() const {
+      if (base::current == end) {
+	throw stop_iteration();
+      } else {
+	return from(static_cast<const value_type&>(*(base::current)));
+      }
+    }
+
+    SciSwigIterator *copy() const
+    {
+      return new self_type(*this);
+    }
+
+    SciSwigIterator *incr(size_t n = 1)
+    {
+      while (n--) {
+	if (base::current == end) {
+	  throw stop_iteration();
+	} else {
+	  ++base::current;
+	}
+      }
+      return this;
+    }
+
+    SciSwigIterator *decr(size_t n = 1)
+    {
+      while (n--) {
+	if (base::current == begin) {
+	  throw stop_iteration();
+	} else {
+	  --base::current;
+	}
+      }
+      return this;
+    }
+
+  private:
+    out_iterator begin;
+    out_iterator end;
+  };
+
+  template<typename OutIter>
+  inline SciSwigIterator*
+  make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, SwigSciObject seq = SwigSciObject())
+  {
+    return new SciSwigIteratorClosed_T<OutIter>(current, begin, end, seq);
+  }
+
+  template<typename OutIter>
+  inline SciSwigIterator*
+  make_output_iterator(const OutIter& current, SwigSciObject seq = SwigSciObject())
+  {
+    return new SciSwigIteratorOpen_T<OutIter>(current, seq);
+  }
+}
+}
+
+
+%fragment("SciSwigIterator");
+namespace swig
+{
+// Throw a StopIteration exception
+  %ignore stop_iteration;
+  struct stop_iteration {};
+
+  %typemap(throws, noblock=1) stop_iteration
+  {
+    SWIG_Scilab_Raise(0, "stop_iteration", NULL);
+    return SWIG_ERROR;
+  }
+
+// Mark methods that return new objects
+  %newobject SciSwigIterator::copy;
+  %newobject SciSwigIterator::operator + (ptrdiff_t n) const;
+  %newobject SciSwigIterator::operator - (ptrdiff_t n) const;
+
+  %nodirector SciSwigIterator;
+
+  %catches(swig::stop_iteration) SciSwigIterator::value() const;
+  %catches(swig::stop_iteration) SciSwigIterator::incr(size_t n = 1);
+  %catches(swig::stop_iteration) SciSwigIterator::decr(size_t n = 1);
+  %catches(std::invalid_argument) SciSwigIterator::distance(const SciSwigIterator &x) const;
+  %catches(std::invalid_argument) SciSwigIterator::equal (const SciSwigIterator &x) const;
+  %catches(swig::stop_iteration) SciSwigIterator::next();
+  %catches(swig::stop_iteration) SciSwigIterator::previous();
+  %catches(swig::stop_iteration) SciSwigIterator::advance(ptrdiff_t n);
+  %catches(swig::stop_iteration) SciSwigIterator::operator += (ptrdiff_t n);
+  %catches(swig::stop_iteration) SciSwigIterator::operator -= (ptrdiff_t n);
+  %catches(swig::stop_iteration) SciSwigIterator::operator + (ptrdiff_t n) const;
+  %catches(swig::stop_iteration) SciSwigIterator::operator - (ptrdiff_t n) const;
+
+  %ignore SciSwigIterator::operator==;
+  %ignore SciSwigIterator::operator!=;
+  %ignore SciSwigIterator::operator++;
+  %ignore SciSwigIterator::operator--;
+  %ignore SciSwigIterator::operator+;
+  %ignore SciSwigIterator::operator-;
+
+  struct SciSwigIterator
+  {
+  protected:
+    SciSwigIterator(SwigSciObject seq);
+
+  public:
+    virtual ~SciSwigIterator();
+
+    virtual SwigSciObject value() const = 0;
+
+    virtual SciSwigIterator *incr(size_t n = 1) = 0;
+
+    virtual SciSwigIterator *decr(size_t n = 1);
+
+    virtual ptrdiff_t distance(const SciSwigIterator &x) const;
+
+    virtual bool equal (const SciSwigIterator &x) const;
+
+    virtual SciSwigIterator *copy() const = 0;
+
+    SwigSciObject next();
+    SwigSciObject previous();
+    SciSwigIterator *advance(ptrdiff_t n);
+
+    bool operator == (const SciSwigIterator& x)  const;
+    bool operator != (const SciSwigIterator& x) const;
+    SciSwigIterator* operator ++ ();
+    SciSwigIterator* operator -- ();
+    SciSwigIterator* operator + (ptrdiff_t n) const;
+    SciSwigIterator* operator - (ptrdiff_t n) const;
+    ptrdiff_t operator - (const SciSwigIterator& x) const;
+  };
+}
diff --git a/share/swig/3.0.12/scilab/scilab.swg b/share/swig/3.0.12/scilab/scilab.swg
new file mode 100644
index 0000000..3b5f6e8
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scilab.swg
@@ -0,0 +1,6 @@
+%include <typemaps/swigmacros.swg>
+%include <typemaps/fragments.swg>
+%include <scimacros.swg>
+%include <sciruntime.swg>
+%include <scitypemaps.swg>
+
diff --git a/share/swig/3.0.12/scilab/scilist.swg b/share/swig/3.0.12/scilab/scilist.swg
new file mode 100644
index 0000000..513f40b
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scilist.swg
@@ -0,0 +1,91 @@
+/*
+ * Scilab list related functions
+ *
+ */
+
+%fragment("SWIG_ScilabList", "header")
+{
+SWIGINTERN int
+SWIG_GetScilabList(SwigSciObject obj, int **piListAddr)
+{
+  SciErr sciErr;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, obj, piListAddr);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  return SWIG_OK;
+}
+
+SWIGINTERN int
+SWIG_GetScilabListSize(SwigSciObject obj, int *piListSize)
+{
+  SciErr sciErr;
+  int *piListAddr;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, obj, &piListAddr);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  sciErr = getListItemNumber(pvApiCtx, piListAddr, piListSize);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  return SWIG_OK;
+}
+
+SWIGINTERN int
+SWIG_GetScilabListAndSize(SwigSciObject obj, int **piListAddr, int *piListSize)
+{
+  SciErr sciErr;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, obj, piListAddr);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  sciErr = getListItemNumber(pvApiCtx, *piListAddr, piListSize);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  return SWIG_OK;
+}
+
+SWIGINTERN int
+SWIG_CheckScilabList(SwigSciObject obj)
+{
+  SciErr sciErr;
+  int *piListAddr;
+  int iType;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, obj, &piListAddr);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  sciErr = getVarType(pvApiCtx, piListAddr, &iType);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if ((iType != sci_list) && (iType != sci_tlist) && (iType != sci_mlist)) {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A list is expected.\n"), SWIG_Scilab_GetFuncName(), obj);
+    return SWIG_ERROR;
+  }
+
+  return SWIG_OK;
+}
+
+}
+
diff --git a/share/swig/3.0.12/scilab/scilong.swg b/share/swig/3.0.12/scilab/scilong.swg
new file mode 100644
index 0000000..4e55be5
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scilong.swg
@@ -0,0 +1,123 @@
+/*
+ * C-type: long
+ * Scilab type: double or int32
+ */
+
+%fragment(SWIG_AsVal_frag(long), "header", fragment="SWIG_SciDoubleOrInt32_AsLong", fragment="<limits.h>") {
+%#define SWIG_AsVal_long(scilabValue, valuePointer) SWIG_SciDoubleOrInt32_AsLong(pvApiCtx, scilabValue, valuePointer, SWIG_Scilab_GetFuncName());
+}
+%fragment("SWIG_SciDoubleOrInt32_AsLong", "header") {
+SWIGINTERN int
+SWIG_SciDoubleOrInt32_AsLong(void *pvApiCtx, SwigSciObject iVar, long *plValue, char *fname) {
+  SciErr sciErr;
+  int iType = 0;
+  int iRows = 0;
+  int iCols = 0;
+  int *piAddrVar = NULL;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  sciErr = getVarType(pvApiCtx, piAddrVar, &iType);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (iType == sci_ints) {
+    int iPrec = 0;
+    int *piData = NULL;
+
+    sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddrVar, &iPrec);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+    if (iPrec != SCI_INT32) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 32-bit signed integer or a double expected.\n"), fname, iVar);
+      return SWIG_TypeError;
+    }
+    sciErr = getMatrixOfInteger32(pvApiCtx, piAddrVar, &iRows, &iCols, &piData);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+    if (iRows * iCols != 1) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong size for input argument #%d: A 32-bit signed integer or a double expected.\n"), fname, iVar);
+      return SWIG_TypeError;
+    }
+    *plValue = (long) *piData;
+  }
+  else if (iType == sci_matrix) {
+    double *pdData = NULL;
+    double dValue = 0.0f;
+
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrVar, &iRows, &iCols, &pdData);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+    if (iRows * iCols != 1) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong size for input argument #%d: A 32-bit signed integer or a double expected.\n"), fname, iVar);
+      return SWIG_TypeError;
+    }
+    dValue = *pdData;
+    if (dValue != floor(dValue)) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 32-bit signed integer.\n"), fname, iVar);
+      return SWIG_ValueError;
+    }
+    if ((dValue < LONG_MIN) || (dValue > LONG_MAX)) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 32-bit signed integer.\n"), fname, iVar);
+      return SWIG_OverflowError;
+    }
+    *plValue = (long) dValue;
+  }
+  else {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 32-bit signed integer or a double expected.\n"), fname, iVar);
+    return SWIG_TypeError;
+  }
+
+  return SWIG_OK;
+}
+}
+
+%fragment(SWIG_From_frag(long), "header", fragment="SWIG_SciDouble_FromLong") {
+%#define SWIG_From_long(scilabValue) SWIG_SciDouble_FromLong(pvApiCtx, SWIG_Scilab_GetOutputPosition(), scilabValue, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_SciDouble_FromLong", "header") {
+SWIGINTERN int
+SWIG_SciDouble_FromLong(void *pvApiCtx, int iVarOut, long lValue, char *fname) {
+  if (createScalarDouble(pvApiCtx,
+    SWIG_NbInputArgument(pvApiCtx) + iVarOut, (double) lValue))
+    return SWIG_ERROR;
+  return SWIG_OK;
+}
+}
+
+
+%fragment("SWIG_SciDouble_FromLongArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciDouble_FromLongArrayAndSize(void *pvApiCtx, int iVarOut, int iRows, int iCols, const long *plData) {
+  SciErr sciErr;
+  int i;
+  double *pdValues = NULL;
+
+  pdValues = (double*) malloc(iRows * iCols * sizeof(double));
+  for (i=0; i<iRows * iCols; i++) {
+    pdValues[i] = plData[i];
+  }
+
+  sciErr = createMatrixOfDouble(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, iRows, iCols, pdValues);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    free(pdValues);
+    return SWIG_ERROR;
+  }
+  free(pdValues);
+  return SWIG_OK;
+}
+}
+
diff --git a/share/swig/3.0.12/scilab/scilonglong.swg b/share/swig/3.0.12/scilab/scilonglong.swg
new file mode 100644
index 0000000..02d9b2f
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scilonglong.swg
@@ -0,0 +1,54 @@
+/*
+ * C-type: long long
+ * Scilab 5 type: NONE
+ * Scilab 6 type: int64
+ */
+%fragment(SWIG_AsVal_frag(long long), "header", fragment="SWIG_SciInt64_ToLongLong") {
+%#define SWIG_AsVal_long_SS_long(scilabValue, valuePointer) SWIG_SciInt64_ToLongLong(pvApiCtx, scilabValue, valuePointer, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_SciInt64_ToLongLong", "header") {
+SWIGINTERN int
+SWIG_SciInt64_ToLongLong(void *pvApiCtx, int iVar, long long *pllValue, char *fname) {
+  Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Scilab 5.X does not manage '%s' data type.\n"), "SWIG_SciInt64_ToLongLong", "int64");
+  return SWIG_ERROR;
+}
+}
+
+%fragment(SWIG_From_frag(long long), "header", fragment="SWIG_SciInt64_FromLongLong") {
+#define SWIG_From_long_SS_long(value) SWIG_SciInt64_FromLongLong(pvApiCtx, $result, value)
+}
+%fragment("SWIG_SciInt64_FromLongLong", "header") {
+SWIGINTERN int
+SWIG_SciInt64_FromLongLong(void *pvApiCtx, int iVarOut, long long llValue) {
+  Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Scilab 5.X does not manage '%s' data type.\n"), "SWIG_SciInt64_ToLongLong", "int64");
+  return SWIG_ERROR;
+}
+}
+
+/*
+ * C-type: unsigned long long
+ * Scilab 5 type: NONE
+ * Scilab 6 type: uint64
+ */
+%fragment(SWIG_AsVal_frag(unsigned long long), "header", fragment="SWIG_SciUint64_ToUnsignedLongLong") {
+#define SWIG_AsVal_unsigned_SS_long_SS_long(scilabValue, valuePointer) SWIG_SciUint64_ToUnsignedLongLong(pvApiCtx, scilabValue, valuePointer, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_SciUint64_ToUnsignedLongLong", "header") {
+SWIGINTERN int
+SWIG_SciUint64_ToUnsignedLongLong(void *pvApiCtx, int iVar, unsigned long long *pullValue, char *fname) {
+  Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Scilab 5.X does not manage '%s' data type.\n"), "SWIG_SciUint64_ToLongLong", "uint64");
+  return SWIG_ERROR;
+}
+}
+
+%fragment(SWIG_From_frag(unsigned long long), "header", fragment="SWIG_SciUint64_FromUnsignedLongLong") {
+#define SWIG_From_unsigned_SS_long_SS_long(value) SWIG_SciUint64_FromUnsignedLongLong(pvApiCtx, $result, value)
+}
+%fragment("SWIG_SciUint64_FromUnsignedLongLong", "header") {
+SWIGINTERN int
+SWIG_SciUint64_FromUnsignedLongLong(void *pvApiCtx, int iVarOut, unsigned long long llValue) {
+  Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Scilab 5.X does not manage '%s' data type.\n"), "SWIG_SciUint64_ToLongLong", "uint64");
+  return SWIG_ERROR;
+}
+}
+
diff --git a/share/swig/3.0.12/scilab/scimacros.swg b/share/swig/3.0.12/scilab/scimacros.swg
new file mode 100644
index 0000000..669ca89
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scimacros.swg
@@ -0,0 +1,5 @@
+ #define %scilabconst(flag) %feature("scilab:const","flag")
+
+// Create Scilab variable
+#define SWIG_CreateScilabVariable_frag(Type...) %fragment_name(CreateScilabVariable, Type)
+#define SWIG_CreateScilabVariable_dec(Type...) %symbol_name(CreateScilabVariable, Type)
diff --git a/share/swig/3.0.12/scilab/scimatrixbool.swg b/share/swig/3.0.12/scilab/scimatrixbool.swg
new file mode 100644
index 0000000..a43886b
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scimatrixbool.swg
@@ -0,0 +1,170 @@
+/*
+ * C-type: bool array
+ * Scilab type: bool matrix
+ */
+
+%include <scibool.swg>
+
+// in (bool *IN, int IN_ROWCOUNT, int IN_COLCOUNT)
+
+%typemap(in, noblock=1, fragment="SWIG_SciBoolean_AsBoolArrayAndSize") (bool *IN, int IN_ROWCOUNT, int IN_COLCOUNT)
+{
+  if (SWIG_SciBoolean_AsBoolArrayAndSize(pvApiCtx, $input, &$2, &$3, &$1, fname) != SWIG_OK) {
+    return SWIG_ERROR;
+  }
+}
+
+// in (int IN_ROWCOUNT, int IN_COLCOUNT, bool *IN)
+
+%typemap(in, noblock=1, fragment="SWIG_SciBoolean_AsBoolArrayAndSize") (int IN_ROWCOUNT, int IN_COLCOUNT, bool *IN)
+{
+  if (SWIG_SciBoolean_AsBoolArrayAndSize(pvApiCtx, $input, &$1, &$2, &$3, fname) != SWIG_OK) {
+    return SWIG_ERROR;
+  }
+}
+
+// in (bool *IN, int IN_SIZE)
+
+%typemap(in, noblock=1, fragment="SWIG_SciBoolean_AsBoolArrayAndSize") (bool *IN, int IN_SIZE) (int rowCount, int colCount)
+{
+  if (SWIG_SciBoolean_AsBoolArrayAndSize(pvApiCtx, $input, &rowCount, &colCount, &$1, fname) == SWIG_OK) {
+    $2 = rowCount * colCount;
+  }
+  else {
+    return SWIG_ERROR;
+  }
+}
+
+// in (int IN_SIZE, bool *IN)
+
+%typemap(in, noblock=1) (int IN_SIZE, bool *IN) (int rowCount, int colCount)
+{
+  if (SWIG_SciBoolean_AsBoolArrayAndSize(pvApiCtx, $input, &rowCount, &colCount, &$2, fname) == SWIG_OK) {
+    $1 = rowCount * colCount;
+  }
+  else {
+    return SWIG_ERROR;
+  }
+}
+
+// out (bool **OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT)
+
+%typemap(in, noblock=1, numinputs=0) (bool **OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT)
+{
+}
+
+%typemap(arginit, noblock=1) (bool **OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT)
+{
+  $1 = (bool**) malloc(sizeof(bool*));
+  $2 = (int*) malloc(sizeof(int));
+  $3 = (int*) malloc(sizeof(int));
+}
+
+%typemap(freearg, noblock=1) (bool **OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT)
+{
+  free(*$1);
+  free($1);
+  free($2);
+  free($3);
+}
+
+%typemap(argout, noblock=1, fragment="SWIG_SciBoolean_FromBoolArrayAndSize") (bool **OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT)
+{
+  if (SWIG_SciBoolean_FromBoolArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), *$2, *$3, *$1) == SWIG_OK) {
+    SWIG_Scilab_SetOutput(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + SWIG_Scilab_GetOutputPosition());
+  }
+  else {
+    return SWIG_ERROR;
+  }
+}
+
+// out (int *OUT_ROWCOUNT, int *OUT_COLCOUNT, bool **OUT)
+
+%typemap(in, noblock=1, numinputs=0) (int *OUT_ROWCOUNT, int *OUT_COLCOUNT, bool **OUT)
+{
+}
+
+%typemap(arginit, noblock=1) (int *OUT_ROWCOUNT, int *OUT_COLCOUNT, bool **OUT)
+{
+  $1 = (int*) malloc(sizeof(int));
+  $2 = (int*) malloc(sizeof(int));
+  $3 = (bool**) malloc(sizeof(bool*));
+}
+
+%typemap(argout, noblock=1, fragment="SWIG_SciBoolean_FromBoolArrayAndSize") (int *OUT_ROWCOUNT, int *OUT_COLCOUNT, bool **OUT)
+{
+  if (SWIG_SciBoolean_FromBoolArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), *$1, *$2, *$3) == SWIG_OK) {
+    SWIG_Scilab_SetOutput(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + SWIG_Scilab_GetOutputPosition());
+  }
+  else {
+    return SWIG_ERROR;
+  }
+}
+
+%typemap(freearg, noblock=1) (int *OUT_ROWCOUNT, int *OUT_COLCOUNT, bool **OUT)
+{
+  free($1);
+  free($2);
+  free(*$3);
+  free($3);
+}
+
+
+// out (bool **OUT, int *OUT_SIZE)
+
+%typemap(in, noblock=1, numinputs=0) (bool **OUT, int *OUT_SIZE)
+{
+}
+
+%typemap(arginit, noblock=1) (bool **OUT, int *OUT_SIZE)
+{
+  $1 = (bool**) malloc(sizeof(bool*));
+  $2 = (int*) malloc(sizeof(int));
+}
+
+%typemap(argout, noblock=1, fragment="SWIG_SciBoolean_FromBoolArrayAndSize") (bool **OUT, int *OUT_SIZE)
+{
+  if (SWIG_SciBoolean_FromBoolArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, *$2, *$1) == SWIG_OK) {
+    SWIG_Scilab_SetOutput(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + SWIG_Scilab_GetOutputPosition());
+  }
+  else {
+    return SWIG_ERROR;
+  }
+}
+
+%typemap(freearg, noblock=1) (bool **OUT, int *OUT_SIZE)
+{
+  free(*$1);
+  free($1);
+  free($2);
+}
+
+
+// out (int *OUT_SIZE, bool **OUT)
+
+%typemap(in, noblock=1, numinputs=0) (int *OUT_SIZE, bool **OUT)
+{
+}
+
+%typemap(arginit, noblock=1) (int *OUT_SIZE, bool **OUT)
+{
+  $1 = (int*) malloc(sizeof(int));
+  $2 = (bool**) malloc(sizeof(bool*));
+}
+
+%typemap(argout, noblock=1, fragment="SWIG_SciBoolean_FromBoolArrayAndSize") (int *OUT_SIZE, bool **OUT)
+{
+  if (SWIG_SciBoolean_FromBoolArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, *$1, *$2) == SWIG_OK) {
+    SWIG_Scilab_SetOutput(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + SWIG_Scilab_GetOutputPosition());
+  }
+  else {
+    return SWIG_ERROR;
+  }
+}
+
+%typemap(freearg, noblock=1) (int *OUT_SIZE, bool **OUT)
+{
+  free($1);
+  free(*$2);
+  free($2);
+}
diff --git a/share/swig/3.0.12/scilab/scimatrixchar.swg b/share/swig/3.0.12/scilab/scimatrixchar.swg
new file mode 100644
index 0000000..37f6833
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scimatrixchar.swg
@@ -0,0 +1,199 @@
+/*
+ * C-type: char*
+ * Scilab type: string matrix
+ */
+
+%include <scichar.swg>
+
+// in (char **IN, int IN_ROWCOUNT, int IN_COLCOUNT)
+
+%typemap(in, noblock=1, fragment="SWIG_SciString_AsCharPtrArrayAndSize") (char **IN, int IN_ROWCOUNT, int IN_COLCOUNT)
+{
+  if (SWIG_SciString_AsCharPtrArrayAndSize(pvApiCtx, $input, &$2, &$3, &$1, fname) != SWIG_OK) {
+    return SWIG_ERROR;
+  }
+}
+
+// in (int IN_ROWCOUNT, int IN_COLCOUNT, char **IN)
+
+%typemap(in, noblock=1, fragment="SWIG_SciString_AsCharPtrArrayAndSize") (int IN_ROWCOUNT, int IN_COLCOUNT, char **IN)
+{
+  if (SWIG_SciString_AsCharPtrArrayAndSize(pvApiCtx, $input, &$1, &$2, &$3, fname) != SWIG_OK) {
+    return SWIG_ERROR;
+  }
+}
+
+// in (char **IN, int IN_SIZE)
+
+%typemap(in, noblock=1, fragment="SWIG_SciString_AsCharPtrArrayAndSize") (char **IN, int IN_SIZE) (int rowCount, int colCount)
+{
+  if (SWIG_SciString_AsCharPtrArrayAndSize(pvApiCtx, $input, &rowCount, &colCount, &$1, fname) == SWIG_OK) {
+    $2 = rowCount * colCount;
+  }
+  else {
+    return SWIG_ERROR;
+  }
+}
+
+// in (int IN_SIZE, char **IN)
+
+%typemap(in, noblock=1, fragment="SWIG_SciString_AsCharPtrArrayAndSize") (int IN_SIZE, char **IN) (int rowCount, int colCount)
+{
+  if (SWIG_SciString_AsCharPtrArrayAndSize(pvApiCtx, $input, &rowCount, &colCount, &$2, fname) == SWIG_OK) {
+    $1 = rowCount * colCount;
+  }
+  else {
+    return SWIG_ERROR;
+  }
+}
+
+// out (char ***OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT)
+
+%typemap(in, noblock=1, numinputs=0) (char ***OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT)
+{
+}
+
+%typemap(arginit, noblock=1) (char ***OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT)
+{
+  $1 = (char***) malloc(sizeof(char**));
+  $2 = (int*) malloc(sizeof(int));
+  $3 = (int*) malloc(sizeof(int));
+}
+
+%typemap(argout, noblock=1, fragment="SWIG_SciString_FromCharPtrArrayAndSize") (char ***OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT)
+{
+  if (SWIG_SciString_FromCharPtrArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), *$2, *$3, *$1) == SWIG_OK) {
+    SWIG_Scilab_SetOutput(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + SWIG_Scilab_GetOutputPosition());
+  }
+  else {
+    return SWIG_ERROR;
+  }
+}
+
+%typemap(freearg, noblock=1) (char ***OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT)
+{
+  {
+    int i;
+    for (i = 0; i < (*$2) * (*$3); i++)
+      free((*$1)[i]);
+  }
+  free(*$1);
+  free($1);
+  free($2);
+  free($3);
+}
+
+// out (int *OUT_ROWCOUNT, int *OUT_COLCOUNT, char ***OUT)
+
+%typemap(in, noblock=1, numinputs=0) (int *OUT_ROWCOUNT, int *OUT_COLCOUNT, char ***OUT)
+{
+}
+
+%typemap(arginit, noblock=1) (int *OUT_ROWCOUNT, int *OUT_COLCOUNT, char ***OUT)
+{
+  $1 = (char***) malloc(sizeof(char**));
+  $2 = (int*) malloc(sizeof(int));
+  $3 = (int**) malloc(sizeof(int*));
+}
+
+%typemap(argout, noblock=1, fragment="SWIG_SciString_FromCharPtrArrayAndSize") (int *OUT_ROWCOUNT, int *OUT_COLCOUNT, char ***OUT)
+{
+  if (SWIG_SciString_FromCharPtrArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), *$1, *$2, *$3) == SWIG_OK) {
+    SWIG_Scilab_SetOutput(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + SWIG_Scilab_GetOutputPosition());
+  }
+  else {
+    return SWIG_ERROR;
+  }
+}
+
+%typemap(freearg, noblock=1) (int *OUT_ROWCOUNT, int *OUT_COLCOUNT, char ***OUT)
+{
+  free($1);
+  free($2);
+  {
+    int i;
+    for (i = 0; i < (*$1) * (*$2); i++)
+      free((*$3)[i]);
+  }
+  free(*$3);
+  free($3);
+}
+
+
+// out (char ***OUT, int *OUT_SIZE)
+
+%typemap(in, noblock=1, numinputs=0) (char ***OUT, int *OUT_SIZE)
+{
+}
+
+%typemap(arginit, noblock=1) (char ***OUT, int *OUT_SIZE)
+{
+  $1 = (char***) malloc(sizeof(char**));
+  $2 = (int*) malloc(sizeof(int));
+}
+
+%typemap(freearg, noblock=1) (char ***OUT, int *OUT_SIZE)
+{
+  {
+    int i;
+    for (i = 0; i < *$2; i++)
+      free((*$1)[i]);
+  }
+  free(*$1);
+  free($1);
+  free($2);
+}
+
+%typemap(argout, noblock=1, fragment="SWIG_SciString_FromCharPtrArrayAndSize") (char ***OUT, int *OUT_SIZE)
+{
+  if (SWIG_SciString_FromCharPtrArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, *$2, *$1) == SWIG_OK) {
+    SWIG_Scilab_SetOutput(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + SWIG_Scilab_GetOutputPosition());
+  }
+  else {
+    return SWIG_ERROR;
+  }
+}
+
+// in (int IN_SIZE, char **IN)
+
+%typemap(in, noblock=1, fragment="SWIG_SciString_AsCharPtrArrayAndSize") (int IN_SIZE, char **IN)
+{
+  if (SWIG_SciString_AsCharPtrArrayAndSize(pvApiCtx, $input, 1, &$1, &$2, fname) != SWIG_OK) {
+    return SWIG_ERROR;
+  }
+}
+
+// out (int *OUT_SIZE, char ***OUT)
+
+%typemap(in, noblock=1, numinputs=0) (int *OUT_SIZE, char ***OUT)
+{
+}
+
+%typemap(arginit, noblock=1) (int *OUT_SIZE, char ***OUT)
+{
+  $1 = (int*) malloc(sizeof(int));
+  $2 = (char***) malloc(sizeof(char**));
+}
+
+%typemap(argout, noblock=1, fragment="SWIG_SciString_FromCharPtrArrayAndSize") (int *OUT_SIZE, char ***OUT)
+{
+  if (SWIG_SciString_FromCharPtrArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, *$1, *$2) == SWIG_OK) {
+    SWIG_Scilab_SetOutput(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + SWIG_Scilab_GetOutputPosition());
+  }
+  else {
+    return SWIG_ERROR;
+  }
+}
+
+%typemap(freearg, noblock=1) (int *OUT_SIZE, char ***OUT)
+{
+  free($1);
+  {
+    int i;
+    for (i = 0; i < *$1; i++)
+      free((*$2)[i]);
+  }
+  free(*$2);
+  free($2);
+}
+
diff --git a/share/swig/3.0.12/scilab/scimatrixdouble.swg b/share/swig/3.0.12/scilab/scimatrixdouble.swg
new file mode 100644
index 0000000..9444a80
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scimatrixdouble.swg
@@ -0,0 +1,170 @@
+/*
+ * C-type: double array
+ * Scilab type: double matrix
+ */
+
+%include <scidouble.swg>
+
+// in (double *IN, int IN_ROWCOUNT, int IN_COLCOUNT)
+
+%typemap(in, noblock=1, fragment="SWIG_SciDouble_AsDoubleArrayAndSize") (double *IN, int IN_ROWCOUNT, int IN_COLCOUNT)
+{
+  if (SWIG_SciDouble_AsDoubleArrayAndSize(pvApiCtx, $input, &$2, &$3, &$1, fname) != SWIG_OK) {
+    return SWIG_ERROR;
+  }
+}
+
+// in (int IN_ROWCOUNT, int IN_COLCOUNT, double *IN)
+
+%typemap(in, noblock=1, fragment="SWIG_SciDouble_AsDoubleArrayAndSize") (int IN_ROWCOUNT, int IN_COLCOUNT, double *IN)
+{
+  if (SWIG_SciDouble_AsDoubleArrayAndSize(pvApiCtx, $input, &$1, &$2, &$3, fname) != SWIG_OK) {
+    return SWIG_ERROR;
+  }
+}
+
+// in (double *IN, int IN_SIZE)
+
+%typemap(in, noblock=1, fragment="SWIG_SciDouble_AsDoubleArrayAndSize") (double *IN, int IN_SIZE) (int rowCount, int colCount)
+{
+  if (SWIG_SciDouble_AsDoubleArrayAndSize(pvApiCtx, $input, &rowCount, &colCount, &$1, fname) == SWIG_OK) {
+	$2 = rowCount * colCount;
+  }
+  else {
+	return SWIG_ERROR;
+  }
+}
+
+// in (int IN_SIZE, double *IN)
+
+%typemap(in, noblock=1, fragment="SWIG_SciDouble_AsDoubleArrayAndSize") (int IN_SIZE, double *IN) (int rowCount, int colCount)
+{
+  if (SWIG_SciDouble_AsDoubleArrayAndSize(pvApiCtx, $input, &rowCount, &colCount, &$2, fname) == SWIG_OK) {
+    $1 = rowCount * colCount;
+  }
+  else {
+    return SWIG_ERROR;
+  }
+}
+
+// out (double **OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT)
+
+%typemap(in, noblock=1, numinputs=0) (double **OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT)
+{
+}
+
+%typemap(arginit, noblock=1) (double **OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT)
+{
+  $1 = (double**) malloc(sizeof(double*));
+  $2 = (int*) malloc(sizeof(int));
+  $3 = (int*) malloc(sizeof(int));
+}
+
+%typemap(freearg, noblock=1) (double **OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT)
+{
+  free(*$1);
+  free($1);
+  free($2);
+  free($3);
+}
+
+%typemap(argout, noblock=1, fragment="SWIG_SciDouble_FromDoubleArrayAndSize") (double **OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT)
+{
+  if (SWIG_SciDouble_FromDoubleArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), *$2, *$3, *$1) == SWIG_OK) {
+    SWIG_Scilab_SetOutput(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + SWIG_Scilab_GetOutputPosition());
+  }
+  else {
+    return SWIG_ERROR;
+  }
+}
+
+// out (int *OUT_ROWCOUNT, int *OUT_COLCOUNT, double **OUT)
+
+%typemap(in, noblock=1, numinputs=0) (int *OUT_ROWCOUNT, int *OUT_COLCOUNT, double **OUT)
+{
+}
+
+%typemap(arginit, noblock=1) (int *OUT_ROWCOUNT, int *OUT_COLCOUNT, double **OUT)
+{
+  $1 = (int*) malloc(sizeof(int));
+  $2 = (int*) malloc(sizeof(int));
+  $3 = (double**) malloc(sizeof(double*));
+}
+
+%typemap(argout, noblock=1, fragment="SWIG_SciDouble_FromDoubleArrayAndSize") (int *IN_ROWCOUNT, int *IN_COLCOUNT, double **OUT)
+{
+  if (SWIG_SciDouble_FromDoubleArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), *$1, *$2, *$3) == SWIG_OK) {
+    SWIG_Scilab_SetOutput(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + SWIG_Scilab_GetOutputPosition());
+  }
+  else {
+    return SWIG_ERROR;
+  }
+}
+
+%typemap(freearg, noblock=1) (int *OUT_ROWCOUNT, int *OUT_COLCOUNT, double **OUT)
+{
+  free($1);
+  free($2);
+  free(*$3);
+  free($3);
+}
+
+
+// out (double **OUT, int *OUT_SIZE)
+
+%typemap(in, noblock=1, numinputs=0) (double **OUT, int *OUT_SIZE)
+{
+}
+
+%typemap(arginit, noblock=1) (double **OUT, int *OUT_SIZE)
+{
+  $1 = (double**) malloc(sizeof(double*));
+  $2 = (int*) malloc(sizeof(int));
+}
+
+%typemap(argout, noblock=1, fragment="SWIG_SciDouble_FromDoubleArrayAndSize") (double **OUT, int *OUT_SIZE)
+{
+  if (SWIG_SciDouble_FromDoubleArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, *$2, *$1) == SWIG_OK) {
+    SWIG_Scilab_SetOutput(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + SWIG_Scilab_GetOutputPosition());
+  }
+  else {
+    return SWIG_ERROR;
+  }
+}
+
+%typemap(freearg, noblock=1) (double **OUT, int *OUT_SIZE)
+{
+  free(*$1);
+  free($1);
+  free($2);
+}
+
+
+// out (int *OUT_SIZE, double **OUT)
+
+%typemap(in, noblock=1, numinputs=0) (int *OUT_SIZE, double **OUT)
+{
+}
+
+%typemap(arginit, noblock=1) (int *OUT_SIZE, double **OUT)
+{
+  $1 = (int*) malloc(sizeof(int));
+  $2 = (double**) malloc(sizeof(double*));
+}
+
+%typemap(argout, noblock=1, fragment="SWIG_SciDouble_FromDoubleArrayAndSize") (int *OUT_SIZE, double **OUT)
+{
+  if (SWIG_SciDouble_FromDoubleArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, *$1, *$2) == SWIG_OK) {
+    SWIG_Scilab_SetOutput(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + SWIG_Scilab_GetOutputPosition());
+  }
+  else {
+    return SWIG_ERROR;
+  }
+}
+
+%typemap(freearg, noblock=1) (int *OUT_SIZE, double **OUT)
+{
+  free($1);
+  free(*$2);
+  free($2);
+}
diff --git a/share/swig/3.0.12/scilab/scimatrixint.swg b/share/swig/3.0.12/scilab/scimatrixint.swg
new file mode 100644
index 0000000..e304d4f
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scimatrixint.swg
@@ -0,0 +1,175 @@
+/*
+ * C-type: int array
+ * Scilab type: 32-bit integer matrix
+ */
+
+%include <sciint.swg>
+
+// in (int *IN, int IN_ROWCOUNT, int IN_COLCOUNT)
+
+%typemap(in, noblock=1, fragment="SWIG_SciDoubleOrInt32_AsIntArrayAndSize") (int *IN, int IN_ROWCOUNT, int IN_COLCOUNT)
+{
+  if (SWIG_SciDoubleOrInt32_AsIntArrayAndSize(pvApiCtx, $input, &$2, &$3, &$1, fname) != SWIG_OK) {
+    return SWIG_ERROR;
+  }
+}
+
+
+// in (int IN_ROWCOUNT, int IN_COLCOUNT, int *IN)
+
+%typemap(in, noblock=1, fragment="SWIG_SciDoubleOrInt32_AsIntArrayAndSize") (int IN_ROWCOUNT, int IN_COLCOUNT, int *IN)
+{
+  if (SWIG_SciDoubleOrInt32_AsIntArrayAndSize(pvApiCtx, $input, &$1, &$2, &$3, fname) != SWIG_OK) {
+    return SWIG_ERROR;
+  }
+}
+
+
+// in (int *IN, int IN_SIZE)
+
+%typemap(in, noblock=1, fragment="SWIG_SciDoubleOrInt32_AsIntArrayAndSize") (int *IN, int IN_SIZE) (int rowCount, int colCount)
+{
+  if (SWIG_SciDoubleOrInt32_AsIntArrayAndSize(pvApiCtx, $input, &rowCount, &colCount, &$1, fname) == SWIG_OK) {
+    $2 = rowCount * colCount;
+  }
+  else {
+    return SWIG_ERROR;
+  }
+}
+
+
+// in (int IN_SIZE, int *IN)
+
+%typemap(in, noblock=1, fragment="SWIG_SciDoubleOrInt32_AsIntArrayAndSize") (int IN_SIZE, int *IN) (int rowCount, int colCount)
+{
+  if (SWIG_SciDoubleOrInt32_AsIntArrayAndSize(pvApiCtx, $input, &rowCount, &colCount, &$2, fname) == SWIG_OK) {
+	$1 = rowCount * colCount;
+  }
+  else {
+	return SWIG_ERROR;
+  }
+}
+
+// out (int **OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT)
+
+%typemap(in, noblock=1, numinputs=0) (int **OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT)
+{
+}
+
+%typemap(arginit, noblock=1) (int **OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT)
+{
+  $1 = (int**) malloc(sizeof(int*));
+  $2 = (int*) malloc(sizeof(int));
+  $3 = (int*) malloc(sizeof(int));
+}
+
+%typemap(argout, noblock=1, fragment="SWIG_SciDouble_FromIntArrayAndSize") (int **OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT)
+{
+  if (SWIG_SciDouble_FromIntArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), *$2, *$3, *$1) == SWIG_OK) {
+    SWIG_Scilab_SetOutput(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + SWIG_Scilab_GetOutputPosition());
+  }
+  else {
+    return SWIG_ERROR;
+  }
+}
+
+%typemap(freearg, noblock=1) (int **OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT)
+{
+  free(*$1);
+  free($1);
+  free($2);
+  free($3);
+}
+
+
+// out (int *OUT_ROWCOUNT, int *OUT_COLCOUNT, int **OUT)
+
+%typemap(in, noblock=1, numinputs=0) (int *OUT_ROWCOUNT, int *OUT_COLCOUNT, int **OUT)
+{
+}
+
+%typemap(arginit, noblock=1) (int *OUT_ROWCOUNT, int *OUT_COLCOUNT, int **OUT)
+{
+  $1 = (int*) malloc(sizeof(int));
+  $2 = (int*) malloc(sizeof(int));
+  $3 = (int**) malloc(sizeof(int*));
+}
+
+%typemap(argout, noblock=1, fragment="SWIG_SciDouble_FromIntArrayAndSize") (int *OUT_ROWCOUNT, int *OUT_COLCOUNT, int **OUT)
+{
+  if (SWIG_SciDouble_FromIntArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), *$1, *$2, *$3) == SWIG_OK) {
+    SWIG_Scilab_SetOutput(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + SWIG_Scilab_GetOutputPosition());
+  }
+  else {
+    return SWIG_ERROR;
+  }
+}
+
+%typemap(freearg, noblock=1) (int *OUT_ROWCOUNT, int *OUT_COLCOUNT, int **OUT)
+{
+  free($1);
+  free($2);
+  free(*$3);
+  free($3);
+}
+
+
+// out (int **OUT, int *OUT_SIZE)
+
+%typemap(in, noblock=1, numinputs=0) (int **OUT, int *OUT_SIZE)
+{
+}
+
+%typemap(arginit) (int **OUT, int *OUT_SIZE)
+{
+  $1 = (int**) malloc(sizeof(int*));
+  $2 = (int*) malloc(sizeof(int));
+}
+
+%typemap(argout, noblock=1, fragment="SWIG_SciDouble_FromIntArrayAndSize") (int **OUT, int *OUT_SIZE)
+{
+  if (SWIG_SciDouble_FromIntArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, *$2, *$1) == SWIG_OK) {
+    SWIG_Scilab_SetOutput(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + SWIG_Scilab_GetOutputPosition());
+  }
+  else {
+    return SWIG_ERROR;
+  }
+}
+
+%typemap(freearg, noblock=1) (int **OUT, int *OUT_SIZE)
+{
+  free(*$1);
+  free($1);
+  free($2);
+}
+
+
+// out (int *OUT_SIZE, int **OUT)
+
+%typemap(in, noblock=1, numinputs=0) (int *OUT_SIZE, int **OUT)
+{
+}
+
+%typemap(arginit, noblock=1) (int *OUT_SIZE, int **OUT)
+{
+  $1 = (int*) malloc(sizeof(int));
+  $2 = (int**) malloc(sizeof(int*));
+}
+
+%typemap(argout, noblock=1, fragment="SWIG_SciDouble_FromIntArrayAndSize") (int *OUT_SIZE, int **OUT)
+{
+  if (SWIG_SciDouble_FromIntArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, *$1, *$2) == SWIG_OK) {
+    SWIG_Scilab_SetOutput(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + SWIG_Scilab_GetOutputPosition());
+  }
+  else {
+    return SWIG_ERROR;
+  }
+}
+
+%typemap(freearg, noblock=1) (int *IN_SIZE, int **OUT)
+{
+  free($1);
+  free(*$2);
+  free($2);
+}
+
diff --git a/share/swig/3.0.12/scilab/scimisctypes.swg b/share/swig/3.0.12/scilab/scimisctypes.swg
new file mode 100644
index 0000000..fe75e15
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scimisctypes.swg
@@ -0,0 +1,69 @@
+// Other primitive such as size_t and ptrdiff_t
+
+/*
+ * C-type: size_t
+ * Scilab type: double or int32
+ */
+
+%fragment(SWIG_AsVal_frag(size_t), "header", fragment="SWIG_Int_AsSize") {
+%#define SWIG_AsVal_size_t(scilabValue, valuePointer) SWIG_Int_AsSize(pvApiCtx, scilabValue, valuePointer, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_Int_AsSize", "header", fragment=SWIG_AsVal_frag(int))
+{
+SWIGINTERN int
+SWIG_Int_AsSize(void *pvApiCtx, SwigSciObject iVar, size_t *piValue, char *fname) {
+  int iValue = 0;
+  if (SWIG_AsVal_dec(int)(iVar, &iValue) != SWIG_OK)
+    return SWIG_ERROR;
+
+  if (piValue)
+    *piValue = (size_t) iValue;
+
+  return SWIG_OK;
+}
+}
+
+%fragment(SWIG_From_frag(size_t), "header", fragment="SWIG_Int_FromSize") {
+%#define SWIG_From_size_t(scilabValue) SWIG_Int_FromSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), scilabValue, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_Int_FromSize", "header", fragment=SWIG_From_frag(int))
+{
+SWIGINTERN int
+SWIG_Int_FromSize(void *pvApiCtx, int iVarOut, size_t iValue, char *fname) {
+  return SWIG_From_dec(int)((int)iValue);
+}
+}
+
+/*
+ * C-type: ptrdiff_t
+ * Scilab type: double or int32
+ */
+
+%fragment(SWIG_AsVal_frag(ptrdiff_t), "header", fragment="SWIG_Int_AsPtrDiff") {
+%#define SWIG_AsVal_ptrdiff_t(scilabValue, valuePointer) SWIG_Int_AsPtrDiff(pvApiCtx, scilabValue, valuePointer, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_Int_AsPtrDiff", "header", fragment=SWIG_AsVal_frag(int))
+{
+SWIGINTERN int
+SWIG_Int_AsPtrDiff(void *pvApiCtx, SwigSciObject iVar, ptrdiff_t *piValue, char *fname) {
+  int iValue = 0;
+  if (SWIG_AsVal_dec(int)(iVar, &iValue) != SWIG_OK)
+    return SWIG_ERROR;
+
+  if (piValue)
+    *piValue = (ptrdiff_t) iValue;
+
+  return SWIG_OK;
+}
+}
+
+%fragment(SWIG_From_frag(ptrdiff_t), "header", fragment="SWIG_Int_FromPtrDiff") {
+%#define SWIG_From_ptrdiff_t(scilabValue) SWIG_Int_FromPtrDiff(pvApiCtx, SWIG_Scilab_GetOutputPosition(), scilabValue, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_Int_FromPtrDiff", "header", fragment=SWIG_From_frag(int)) {
+SWIGINTERN int
+SWIG_Int_FromPtrDiff(void *pvApiCtx, int iVarOut, ptrdiff_t iValue, char *fname) {
+  return SWIG_From_dec(int)((int)iValue);
+}
+}
+
diff --git a/share/swig/3.0.12/scilab/scipointer.swg b/share/swig/3.0.12/scilab/scipointer.swg
new file mode 100644
index 0000000..94ca4ef
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scipointer.swg
@@ -0,0 +1,32 @@
+/*
+ * POINTER
+ */
+%fragment("SWIG_ConvertPtr", "header") {
+#define SWIG_ConvertPtr(scilabValue, voidPointer, pointerDescriptor, flags) SwigScilabPtrToObject(pvApiCtx, scilabValue, voidPointer, pointerDescriptor, flags, SWIG_Scilab_GetFuncName())
+}
+
+%fragment("SWIG_NewPointerObj", "header") {
+#define SWIG_NewPointerObj(pointer, pointerDescriptor, flags) SwigScilabPtrFromObject(pvApiCtx, SWIG_Scilab_GetOutputPosition(), pointer, pointerDescriptor, flags, NULL)
+}
+
+/*
+ * FUNCTION POINTER
+ */
+%fragment("SWIG_ConvertFunctionPtr", "header") {
+#define SWIG_ConvertFunctionPtr(scilabValue, voidPointer, pointerDescriptor) SwigScilabPtrToObject(pvApiCtx, scilabValue, voidPointer, pointerDescriptor, 0, SWIG_Scilab_GetFuncName())
+}
+
+%fragment("SWIG_NewFunctionPtrObj", "header") {
+#define SWIG_NewFunctionPtrObj(pointer, pointerDescriptor) SwigScilabPtrFromObject(pvApiCtx, SWIG_Scilab_GetOutputPosition(), pointer, pointerDescriptor, 0, NULL)
+}
+// No fragment used here, the functions "SwigScilabPtrToObject" and "SwigScilabPtrFromObject" are defined in sciruntime.swg
+
+/*
+ * C++ member pointers, ie, member methods
+ */
+%fragment("SWIG_NewMemberObj", "header") {
+#define SWIG_NewMemberObj(ptr, sz, tp) SWIG_Scilab_NewMemberObj(pvApiCtx, $result, ptr, sz, tp)
+}
+%fragment("SWIG_ConvertMember", "header") {
+#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Scilab_ConvertPacked(pvApiCtx, obj, ptr, sz, ty, SWIG_Scilab_GetFuncName())
+}
diff --git a/share/swig/3.0.12/scilab/sciprimtypes.swg b/share/swig/3.0.12/scilab/sciprimtypes.swg
new file mode 100644
index 0000000..b5e30d9
--- /dev/null
+++ b/share/swig/3.0.12/scilab/sciprimtypes.swg
@@ -0,0 +1,23 @@
+%include <scidouble.swg>
+%include <scifloat.swg>
+
+%include <scilonglong.swg>
+
+%include <sciint.swg>
+%include <sciunsignedint.swg>
+
+%include <scilong.swg>
+%include <sciunsignedlong.swg>
+
+%include <scishort.swg>
+%include <sciunsignedshort.swg>
+
+%include <scichar.swg>
+%include <scisignedchar.swg>
+%include <sciunsignedchar.swg>
+
+%include <scimisctypes.swg>
+
+%include <scipointer.swg>
+%include <scibool.swg>
+
diff --git a/share/swig/3.0.12/scilab/scirun.swg b/share/swig/3.0.12/scilab/scirun.swg
new file mode 100644
index 0000000..29f8096
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scirun.swg
@@ -0,0 +1,481 @@
+/* -----------------------------------------------------------------------------
+ * Scilab support runtime
+ * -----------------------------------------------------------------------------*/
+
+/* Scilab version macro */
+
+#include "version.h"
+#define SWIG_SCILAB_VERSION (SCI_VERSION_MAJOR * 100) + (SCI_VERSION_MINOR * 10) + SCI_VERSION_MAINTENANCE
+
+/* Scilab standard headers */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "api_scilab.h"
+#if SWIG_SCILAB_VERSION < 540
+#define __USE_DEPRECATED_STACK_FUNCTIONS__
+#include "stack-c.h"
+#endif
+#if SWIG_SCILAB_VERSION < 600
+#include "MALLOC.h"
+#endif
+#include "Scierror.h"
+#include "localization.h"
+#include "freeArrayOfString.h"
+#include <sci_gateway.h>
+#include <mex.h>
+#ifdef __cplusplus
+}
+#endif
+
+/* Gateway signature */
+
+#if SWIG_SCILAB_VERSION >= 600
+#define SWIG_GatewayParameters char* fname, void *pvApiCtx
+#define SWIG_GatewayArguments fname, pvApiCtx
+#else
+#define SWIG_GatewayParameters char* fname, unsigned long fname_len
+#define SWIG_GatewayArguments fname, fname_len
+#endif
+
+/* Function name management functions */
+
+#include <stdlib.h>
+static char *SwigFuncName = NULL;
+static char *SWIG_Scilab_GetFuncName(void) {
+  return SwigFuncName;
+}
+static void SWIG_Scilab_SetFuncName(char *funcName) {
+  if (SwigFuncName != NULL) {
+    free(SwigFuncName);
+  }
+  SwigFuncName = strdup(funcName);
+}
+
+/* Api context management functions */
+
+#if SWIG_SCILAB_VERSION >= 600
+static void *pvApiCtx = NULL;
+static void SWIG_Scilab_SetApiContext(void *apiCtx) {
+  pvApiCtx = apiCtx;
+}
+#else
+#define SWIG_Scilab_SetApiContext(apiCtx)
+#endif
+
+/* Argument management functions */
+
+#if SWIG_SCILAB_VERSION >= 540
+#define SWIG_CheckInputArgument(pvApiCtx, minInputArgument, maxInputArgument) CheckInputArgument(pvApiCtx, minInputArgument, maxInputArgument)
+#define SWIG_CheckInputArgumentAtLeast(pvApiCtx, minInputArgument) CheckInputArgumentAtLeast(pvApiCtx, minInputArgument)
+#define SWIG_CheckOutputArgument(pvApiCtx, minOutputArgument, maxOutputArgument) CheckOutputArgument(pvApiCtx, minOutputArgument, maxOutputArgument)
+#define SWIG_NbInputArgument(pvApiCtx) nbInputArgument(pvApiCtx)
+#define SWIG_AssignOutputArgument(pvApiCtx, outputArgumentPos, argumentPos) AssignOutputVariable(pvApiCtx, outputArgumentPos) = argumentPos
+#else
+#define SWIG_CheckInputArgument(pvApiCtx, minInputArgument, maxInputArgument) CheckRhs(minInputArgument, maxInputArgument)
+#define SWIG_CheckInputArgumentAtLeast(pvApiCtx, minInputArgument) CheckRhs(minInputArgument, 256)
+#define SWIG_CheckOutputArgument(pvApiCtx, minOutputArgument, maxOutputArgument) CheckLhs(minOutputArgument, maxOutputArgument)
+#define SWIG_NbInputArgument(pvApiCtx) Rhs
+#define SWIG_AssignOutputArgument(pvApiCtx, outputArgumentPos, argumentPos) LhsVar(outputArgumentPos) = argumentPos
+#endif
+
+typedef int SwigSciObject;
+
+static int SwigOutputPosition = -1;
+static int SWIG_Scilab_GetOutputPosition(void) {
+  return SwigOutputPosition;
+}
+static void SWIG_Scilab_SetOutputPosition(int outputPosition) {
+  SwigOutputPosition = outputPosition;
+}
+
+SWIGRUNTIME int
+SWIG_Scilab_SetOutput(void *pvApiCtx, SwigSciObject output) {
+  int outputPosition = SWIG_Scilab_GetOutputPosition();
+  if (outputPosition < 0)
+      return SWIG_ERROR;
+  SWIG_AssignOutputArgument(pvApiCtx, outputPosition,
+    SWIG_NbInputArgument(pvApiCtx) + outputPosition);
+  return SWIG_OK;
+}
+
+/* Error functions */
+
+#define SCILAB_API_ARGUMENT_ERROR 999
+
+SWIGINTERN const char*
+SWIG_Scilab_ErrorType(int code) {
+  switch(code) {
+  case SWIG_MemoryError:
+    return "MemoryError";
+  case SWIG_IOError:
+    return "IOError";
+  case SWIG_RuntimeError:
+    return "RuntimeError";
+  case SWIG_IndexError:
+    return "IndexError";
+  case SWIG_TypeError:
+    return "TypeError";
+  case SWIG_DivisionByZero:
+    return "ZeroDivisionError";
+  case SWIG_OverflowError:
+    return "OverflowError";
+  case SWIG_SyntaxError:
+    return "SyntaxError";
+  case SWIG_ValueError:
+    return "ValueError";
+  case SWIG_SystemError:
+    return "SystemError";
+  case SWIG_AttributeError:
+    return "AttributeError";
+  default:
+    return "RuntimeError";
+  }
+}
+#define SWIG_ErrorType(code) SWIG_Scilab_ErrorType(code)
+
+#ifndef SWIG_SCILAB_ERROR
+#define SWIG_SCILAB_ERROR 20000
+#endif
+
+SWIGINTERN void
+SWIG_Scilab_Error(int code, const char *msg) {
+  Scierror(SWIG_SCILAB_ERROR - code, _("SWIG/Scilab: %s: %s\n"), SWIG_Scilab_ErrorType(code), msg);
+}
+
+#define SWIG_Error(code, msg) SWIG_Scilab_Error(code, msg)
+
+#define SWIG_fail return SWIG_ERROR;
+
+SWIGRUNTIME void
+SWIG_Scilab_Raise_Ex(const char *obj, const char *type, swig_type_info *descriptor) {
+  if (type) {
+    if (obj)
+      Scierror(SWIG_SCILAB_ERROR, "SWIG/Scilab: Exception (%s) occured: %s\n", type, obj);
+    else
+      Scierror(SWIG_SCILAB_ERROR, "SWIG/Scilab: Exception (%s) occured.\n", type);
+  }
+}
+
+SWIGRUNTIME void
+SWIG_Scilab_Raise(const int obj, const char *type, swig_type_info *descriptor) {
+  Scierror(SWIG_SCILAB_ERROR, "SWIG/Scilab: Exception (%s) occured.\n", type);
+}
+
+/* Module initialization */
+
+static int swig_module_initialized = 0;
+
+SWIGRUNTIME int
+SWIG_Module_Initialized() {
+  return swig_module_initialized;
+}
+
+/* Pointer conversion functions */
+
+SWIGRUNTIME swig_type_info *
+SWIG_Scilab_TypeQuery(const char *name);
+
+SWIGINTERN int
+SwigScilabCheckPtr(void *pvApiCtx, int iVar, swig_type_info *descriptor, char *fname) {
+  SciErr sciErr;
+  int *piAddrVar = NULL;
+  int iType = 0;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  sciErr = getVarType(pvApiCtx, piAddrVar, &iType);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (iType == sci_mlist) {
+    int iItemCount = 0;
+    void *pvTypeinfo = NULL;
+
+    sciErr = getListItemNumber(pvApiCtx, piAddrVar, &iItemCount);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+    if (iItemCount < 3) {
+      return SWIG_ERROR;
+    }
+
+    sciErr = getPointerInList(pvApiCtx, piAddrVar, 2, &pvTypeinfo);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+
+    if (descriptor) {
+      swig_cast_info *cast = SWIG_TypeCheck(SWIG_TypeName((swig_type_info*)pvTypeinfo), descriptor);
+      return (cast != NULL);
+    }
+    else {
+      return SWIG_ERROR;
+    }
+  }
+  else {
+    return (iType == sci_pointer);
+  }
+}
+
+SWIGINTERN int
+SwigScilabPtrToObject(void *pvApiCtx, int iVar, void **pvObj, swig_type_info *descriptor, int flags, char *fname) {
+  SciErr sciErr;
+  int *piAddrVar = NULL;
+  int iType = 0;
+  void *pvPtr = NULL;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  sciErr = getVarType(pvApiCtx, piAddrVar, &iType);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (iType == sci_mlist) {
+    int iItemCount = 0;
+    void *pvTypeinfo = NULL;
+
+    sciErr = getListItemNumber(pvApiCtx, piAddrVar, &iItemCount);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+    if (iItemCount < 3) {
+      return SWIG_ERROR;
+    }
+
+    sciErr = getPointerInList(pvApiCtx, piAddrVar, 2, &pvTypeinfo);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+
+    sciErr = getPointerInList(pvApiCtx, piAddrVar, 3, &pvPtr);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+
+    if (pvPtr) {
+      if (descriptor) {
+        swig_cast_info *cast = SWIG_TypeCheck(SWIG_TypeName((swig_type_info *)pvTypeinfo), descriptor);
+        if (cast) {
+          int newmemory = 0;
+          pvPtr = SWIG_TypeCast(cast, pvPtr, &newmemory);
+          // TODO newmemory
+        }
+        else {
+          return SWIG_ERROR;
+        }
+      }
+    }
+  }
+  else if (iType == sci_pointer) {
+    sciErr = getPointer(pvApiCtx, piAddrVar, &pvPtr);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+  }
+  else {
+    return SWIG_ERROR;
+  }
+
+  if (pvObj) {
+    *pvObj = pvPtr;
+    return SWIG_OK;
+  }
+  else {
+    return SWIG_ERROR;
+  }
+}
+
+SWIGRUNTIMEINLINE int
+SwigScilabPtrFromObject(void *pvApiCtx, int iVarOut, void *pvObj, swig_type_info *descriptor, int flags, const char *pstTypeName) {
+  SciErr sciErr;
+
+  if (descriptor) {
+    int *piMListAddr = NULL;
+
+    sciErr = createMList(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, 3, &piMListAddr);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+
+    if (pstTypeName == NULL) {
+      pstTypeName = SWIG_TypeName(descriptor);
+    }
+
+    sciErr = createMatrixOfStringInList(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, piMListAddr, 1, 1, 1, &pstTypeName);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+
+    sciErr = createPointerInList(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, piMListAddr, 2, descriptor);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+
+    sciErr = createPointerInList(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, piMListAddr, 3, pvObj);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+  }
+  else {
+    sciErr = createPointer(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, pvObj);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+  }
+
+  return SWIG_OK;
+}
+
+/* Pointer argument conversions */
+
+
+SWIGRUNTIME int
+SWIG_Scilab_ConvertPacked(void *pvApiCtx, int iVar, void *ptr, int sz, swig_type_info *ty, char *fname) {
+  swig_cast_info *tc;
+  int *piAddrVar = NULL;
+  char *pstString = NULL;
+  char *pstStringPtr = NULL;
+  SciErr sciErr;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (getAllocatedSingleString(pvApiCtx, piAddrVar, &pstString)) {
+    return SWIG_ERROR;
+  }
+
+  /* Pointer values must start with leading underscore */
+  if (*pstString != '_') {
+    freeAllocatedSingleString(pstString);
+    return SWIG_ERROR;
+  }
+
+  pstStringPtr = pstString;
+  pstStringPtr++;
+  pstStringPtr = (char*)SWIG_UnpackData(pstStringPtr, ptr, sz);
+
+  if (ty) {
+    if (!pstStringPtr) {
+      freeAllocatedSingleString(pstString);
+      return SWIG_ERROR;
+    }
+    tc = SWIG_TypeCheck(pstStringPtr, ty);
+    if (!tc) {
+      freeAllocatedSingleString(pstString);
+      return SWIG_ERROR;
+    }
+  }
+
+  freeAllocatedSingleString(pstString);
+  return SWIG_OK;
+}
+
+SWIGRUNTIME int
+SWIG_Scilab_NewMemberObj(void *pvApiCtx, int iVarOut, void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+
+  if ((2*sz + 1 + strlen(type->name)) > 1000) {
+    return SWIG_ERROR;
+  }
+  *(r++) = '_';
+  r = SWIG_PackData(r, ptr, sz);
+  strcpy(r, type->name);
+
+  if (createSingleString(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, &result[0]))
+    return SWIG_ERROR;
+
+  return SWIG_OK;
+}
+
+
+
+
+/*
+ *  Pointer utility functions
+ */
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C"
+#endif
+int SWIG_this(SWIG_GatewayParameters) {
+  void *ptrValue = NULL;
+  if (SwigScilabPtrToObject(pvApiCtx, 1, &ptrValue, NULL, 0, fname) == SWIG_OK) {
+    SWIG_Scilab_SetOutputPosition(1);
+    return SWIG_Scilab_SetOutput(pvApiCtx,
+      createScalarDouble(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + 1,
+        (double)(uintptr_t)ptrValue));
+  }
+  else {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Incorrect value for input argument #%d: The value is not a pointer.\n"), fname, 1);
+    return SWIG_ERROR;
+  }
+}
+
+#ifdef __cplusplus
+extern "C"
+#endif
+int SWIG_ptr(SWIG_GatewayParameters) {
+  void *ptrValue = NULL;
+  double dValue = 0;
+  if (SwigScilabPtrToObject(pvApiCtx, 1, &ptrValue, NULL, 0, fname) == SWIG_OK) {
+    SWIG_Scilab_SetOutputPosition(1);
+    return SWIG_Scilab_SetOutput(pvApiCtx,
+      SwigScilabPtrFromObject(pvApiCtx, 1, ptrValue, NULL, 0, NULL));
+  }
+  else {
+    int *piAddr;
+    SciErr sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+    if(sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+    if (getScalarDouble(pvApiCtx, piAddr, &dValue) == 0) {
+      if (dValue != (uintptr_t)dValue) {
+        Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a pointer.\n"), fname, 1);
+        return SWIG_ValueError;
+      }
+      if ((dValue < 0) || (dValue > ULONG_MAX)) {
+        Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a pointer.\n"), fname, 1);
+        return SWIG_OverflowError;
+      }
+      SWIG_Scilab_SetOutputPosition(1);
+      return SWIG_Scilab_SetOutput(pvApiCtx,
+        SwigScilabPtrFromObject(pvApiCtx, 1, (void *) (uintptr_t)dValue, NULL, 0, NULL));
+    }
+    else {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A pointer or a double expected.\n"), "SWIG_ptr", 1);
+      return SWIG_TypeError;
+    }
+  }
+}
diff --git a/share/swig/3.0.12/scilab/sciruntime.swg b/share/swig/3.0.12/scilab/sciruntime.swg
new file mode 100644
index 0000000..9abedfe
--- /dev/null
+++ b/share/swig/3.0.12/scilab/sciruntime.swg
@@ -0,0 +1,45 @@
+%insert(runtime) "swigrun.swg";
+%insert(runtime) "swigerrors.swg";
+
+%insert(runtime) "scirun.swg";
+
+%insert(init) %{
+/* Module management functions */
+
+#define SWIG_GetModule(clientdata) SWIG_Scilab_GetModule()
+#define SWIG_SetModule(clientdata, pointer) SWIG_Scilab_SetModule(pointer)
+
+SWIGRUNTIME swig_module_info*
+SWIG_Scilab_GetModule(void) {
+  return NULL;
+}
+
+SWIGRUNTIME void
+SWIG_Scilab_SetModule(swig_module_info *swig_module) {
+}
+%}
+
+%insert(init) "swiginit.swg"
+
+%insert(init) %{
+SWIGRUNTIME swig_type_info *
+SWIG_Scilab_TypeQuery(const char *name) {
+  if (SWIG_Module_Initialized()) {
+    return SWIG_TypeQuery(name);
+  }
+  else {
+    SWIG_Error(SWIG_RuntimeError, "the module is not initialized");
+    return NULL;
+  }
+}
+%}
+
+%insert(init) %{
+#ifdef __cplusplus
+extern "C"
+#endif
+int <module>_Init(SWIG_GatewayParameters) {
+  SWIG_InitializeModule(NULL);
+  SWIG_CreateScilabVariables(pvApiCtx);
+  swig_module_initialized = 1;
+%}
diff --git a/share/swig/3.0.12/scilab/scisequence.swg b/share/swig/3.0.12/scilab/scisequence.swg
new file mode 100644
index 0000000..5fe0fdb
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scisequence.swg
@@ -0,0 +1,195 @@
+/*
+ *
+ * Scilab sequence conversions
+ *
+ */
+
+#define SWIG_Traits_Sequence_frag(Type) %fragment_name(AsVal_Traits_Sequence, Type)
+
+#define SWIG_AsCheck_Sequence_frag(Type...) %fragment_name(AsCheck_Sequence, Type)
+#define SWIG_AsCheck_Sequence_dec(Type...) %symbol_name(AsCheck_Sequence, Type)
+#define SWIG_AsGet_Sequence_frag(Type...) %fragment_name(AsGet_Sequence, Type)
+#define SWIG_AsGet_Sequence_dec(Type...) %symbol_name(AsGet_Sequence, Type)
+#define SWIG_AsSize_Sequence_frag(Type...) %fragment_name(AsSize_Sequence, Type)
+#define SWIG_AsSize_Sequence_dec(Type...) %symbol_name(AsSize_Sequence, Type)
+#define SWIG_FromCreate_Sequence_frag(Type...) %fragment_name(FromCreate_Sequence, Type)
+#define SWIG_FromCreate_Sequence_dec(Type...) %symbol_name(FromCreate_Sequence, Type)
+#define SWIG_FromSet_Sequence_frag(Type...) %fragment_name(FromSet_Sequence, Type)
+#define SWIG_FromSet_Sequence_dec(Type...) %symbol_name(FromSet_Sequence, Type)
+
+#define SWIG_Traits_SequenceItem_frag(Type) %fragment_name(AsVal_Traits_SequenceItem, Type)
+#define SWIG_AsVal_SequenceItem_frag(Type...) %fragment_name(AsVal_SequenceItem, Type)
+#define SWIG_AsVal_SequenceItem_dec(Type...) %symbol_name(AsVal_SequenceItem, Type)
+#define SWIG_From_SequenceItem_frag(Type...) %fragment_name(From_SequenceItem, Type)
+#define SWIG_From_SequenceItem_dec(Type...) %symbol_name(From_SequenceItem, Type)
+
+%include <scisequencepointer.swg>
+%include <scisequenceint.swg>
+%include <scisequencedouble.swg>
+%include <scisequencefloat.swg>
+%include <scisequencestring.swg>
+%include <scisequencebool.swg>
+
+//
+// Sequence conversion
+//
+
+%fragment(SWIG_Traits_Sequence_frag(ptr), "header",
+  fragment=SWIG_AsCheck_Sequence_frag(ptr),
+  fragment=SWIG_AsGet_Sequence_frag(ptr),
+  fragment=SWIG_AsSize_Sequence_frag(ptr),
+  fragment=SWIG_FromCreate_Sequence_frag(ptr),
+  fragment=SWIG_FromSet_Sequence_frag(ptr),
+  fragment="StdTraits",
+  fragment="<stdint.h>") {
+
+namespace swig {
+  // Error returned for sequence containers of default item type
+  template <typename T> struct traits_as_sequence {
+    static int check(SwigSciObject obj) {
+      throw std::invalid_argument("The container data type is not supported."); 
+    }
+    static int get(SwigSciObject obj, void **sequence) {
+      throw std::invalid_argument("The container data type is not supported."); 
+    }
+    static int size(SwigSciObject obj, int *size) {
+      throw std::invalid_argument("The container data type is not supported."); 
+    }
+  };
+  template <typename T> struct traits_from_sequence {
+    static int create(int size, void **sequence) {
+      throw std::invalid_argument("The container data type is not supported."); 
+    }
+    static SwigSciObject set(int size, void *sequence) {
+      throw std::invalid_argument("The container data type is not supported.");       
+    }
+  };
+
+  // Support sequence containers of pointers
+  template <typename T> struct traits_as_sequence<T*> {
+    static int check(SwigSciObject obj) {
+      return SWIG_AsCheck_Sequence_dec(ptr)(obj);
+    }
+    static int get(SwigSciObject obj, void **sequence) {
+      return SWIG_AsGet_Sequence_dec(ptr)(obj, (int **)sequence);
+    }
+    static int size(SwigSciObject obj, int *size) {
+      return SWIG_AsSize_Sequence_dec(ptr)(obj, size);
+    }
+  };
+  template <typename T> struct traits_from_sequence<T*> {
+    static int create(int size, void **sequence) {
+      return SWIG_FromCreate_Sequence_dec(ptr)(size, (uintptr_t **)sequence);
+    }
+    static SwigSciObject set(int size, void *sequence) {
+      return SWIG_FromSet_Sequence_dec(ptr)(size, (uintptr_t *)sequence);
+    }
+  };
+}
+}
+
+%define %traits_sequence(CppType, ScilabType)
+  %fragment(SWIG_Traits_Sequence_frag(CppType), "header",
+    fragment=SWIG_Traits_Sequence_frag(ptr),
+    fragment=SWIG_AsCheck_Sequence_frag(CppType),
+    fragment=SWIG_AsGet_Sequence_frag(CppType),
+    fragment=SWIG_AsSize_Sequence_frag(CppType),
+    fragment=SWIG_FromCreate_Sequence_frag(CppType),
+    fragment=SWIG_FromSet_Sequence_frag(CppType)) {
+
+namespace swig {
+  template <> struct traits_as_sequence<CppType > {
+    static int check(SwigSciObject obj) {
+      return SWIG_AsCheck_Sequence_dec(CppType)(obj);
+    }
+    static int get(SwigSciObject obj, void **sequence) {
+      return SWIG_AsGet_Sequence_dec(CppType)(obj, (ScilabType **)sequence);
+    }
+    static int size(SwigSciObject obj, int *size) {
+      return SWIG_AsSize_Sequence_dec(CppType)(obj, size);
+    }
+  };
+  template <> struct traits_from_sequence<CppType > {
+    static int create(int size, void **sequence) {
+      return SWIG_FromCreate_Sequence_dec(CppType)(size, (ScilabType **)sequence);
+    }
+    static SwigSciObject set(int size, void *sequence) {
+      return SWIG_FromSet_Sequence_dec(CppType)(size, (ScilabType *)sequence);
+    }
+  };
+}
+}
+%enddef
+
+
+//
+// Sequence item conversion
+//
+
+%fragment(SWIG_Traits_SequenceItem_frag(ptr), "header",
+  fragment=SWIG_AsVal_SequenceItem_frag(ptr),
+  fragment=SWIG_From_SequenceItem_frag(ptr),
+  fragment="StdTraits",
+  fragment="<stdint.h>") {
+
+namespace swig {
+  // Error returned for sequence containers of default item type
+  template <typename T> struct traits_asval_sequenceitem {
+    static T asval(SwigSciObject obj, void *pSequence, int iItemIndex) {
+      throw std::invalid_argument("The container data type is not supported."); 
+    }
+  };
+  template <typename T> struct traits_from_sequenceitem {
+    static int from(void *pSequence, int iItemIndex, T itemValue) {
+      throw std::invalid_argument("The container data type is not supported."); 
+    }
+  };
+
+  // Support sequence containers of pointers
+  template <typename T> struct traits_asval_sequenceitem<T*> {
+    static T* asval(SwigSciObject obj, void *pSequence, int iItemIndex) {
+      return static_cast<T*>(SWIG_AsVal_SequenceItem_dec(ptr)(obj, (int *)pSequence, iItemIndex));
+    }
+  };
+  template <typename T> struct traits_from_sequenceitem<T*> {
+    static int from(void *pSequence, int iItemIndex, T *itemValue) {
+      return SWIG_From_SequenceItem_dec(ptr)((uintptr_t *)pSequence, iItemIndex, (uintptr_t) itemValue);
+     }
+   };
+}
+}
+
+%define %traits_sequenceitem(CppType, ScilabType)
+  %fragment(SWIG_Traits_SequenceItem_frag(CppType), "header",
+    fragment=SWIG_Traits_SequenceItem_frag(ptr),
+    fragment=SWIG_AsVal_SequenceItem_frag(CppType),
+    fragment=SWIG_From_SequenceItem_frag(CppType)) {
+
+namespace swig {
+  template <> struct traits_asval_sequenceitem<CppType > {
+    static CppType asval(SwigSciObject obj, void *pSequence, int iItemIndex) {
+      return SWIG_AsVal_SequenceItem_dec(CppType)(obj, (ScilabType *)pSequence, iItemIndex);
+    }
+  };
+  template <> struct traits_from_sequenceitem<CppType > {
+    static int from(void *pSequence, int iItemIndex, CppType itemValue) {
+      return SWIG_From_SequenceItem_dec(CppType)((ScilabType *)pSequence, iItemIndex, itemValue);
+    }
+  };
+}
+}
+%enddef
+
+%define %add_traits_sequence(CppType, ScilabType)
+  %traits_sequence(CppType, ScilabType);
+  %fragment(SWIG_Traits_Sequence_frag(CppType));
+  %traits_sequenceitem(CppType, ScilabType);
+  %fragment(SWIG_Traits_SequenceItem_frag(CppType));
+%enddef
+
+%add_traits_sequence(int, int);
+%add_traits_sequence(double, double);
+%add_traits_sequence(float, float);
+%add_traits_sequence(std::string, char*);
+%add_traits_sequence(bool, int);
+
diff --git a/share/swig/3.0.12/scilab/scisequencebool.swg b/share/swig/3.0.12/scilab/scisequencebool.swg
new file mode 100644
index 0000000..b7d0784
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scisequencebool.swg
@@ -0,0 +1,98 @@
+/*
+ *
+ * Scilab matrix of bool <-> C++ bool container
+ *
+ */
+
+%include <scibool.swg>
+
+%fragment(SWIG_AsCheck_Sequence_frag(bool), "header") {
+
+SWIGINTERN int
+SWIG_AsCheck_Sequence_dec(bool)(SwigSciObject obj) {
+  SciErr sciErr;
+  int *piAddrVar;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, obj, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (isBooleanType(pvApiCtx, piAddrVar)) {
+    return SWIG_OK;
+  }
+  else {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A boolean is expected.\n"), SWIG_Scilab_GetFuncName(), obj);
+    return SWIG_ERROR;
+  }
+}
+}
+
+%fragment(SWIG_AsGet_Sequence_frag(bool), "header",
+  fragment="SWIG_SciBoolean_AsIntArrayAndSize") {
+
+SWIGINTERN int
+SWIG_AsGet_Sequence_dec(bool)(SwigSciObject obj, int **pSequence) {
+  int iMatrixRowCount;
+  int iMatrixColCount;
+  return (SWIG_SciBoolean_AsIntArrayAndSize(pvApiCtx, obj, &iMatrixRowCount, &iMatrixColCount, pSequence, SWIG_Scilab_GetFuncName()));
+}
+}
+
+%fragment(SWIG_AsSize_Sequence_frag(bool), "header",
+  fragment="SWIG_SciBoolean_AsIntArrayAndSize") {
+
+SWIGINTERN int
+SWIG_AsSize_Sequence_dec(bool)(SwigSciObject obj, int *piSize) {
+  int *piMatrix;
+  int iMatrixRowCount;
+  int iMatrixColCount;
+  if (SWIG_SciBoolean_AsIntArrayAndSize(pvApiCtx, obj, &iMatrixRowCount, &iMatrixColCount, &piMatrix, SWIG_Scilab_GetFuncName()) == SWIG_OK) {
+    if ((iMatrixRowCount > 1) && (iMatrixColCount > 1)) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong size for input argument #%d: An integer vector is expected.\n"), SWIG_Scilab_GetFuncName(), obj);
+      return SWIG_ERROR;
+    }
+    *piSize = iMatrixRowCount * iMatrixColCount;
+    return SWIG_OK;
+  }
+  return SWIG_ERROR;
+}
+}
+
+%fragment(SWIG_FromCreate_Sequence_frag(bool), "header") {
+
+SWIGINTERN int
+SWIG_FromCreate_Sequence_dec(bool)(int size, int **pSequence) {
+  *pSequence = new int[size];
+  return *pSequence != NULL ? SWIG_OK : SWIG_ERROR;
+}
+}
+
+%fragment(SWIG_FromSet_Sequence_frag(bool), "header",
+  fragment="SWIG_SciBoolean_FromIntArrayAndSize") {
+
+SWIGINTERN SwigSciObject
+SWIG_FromSet_Sequence_dec(bool)(int size, int *pSequence) {
+  SwigSciObject obj = SWIG_SciBoolean_FromIntArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, size, pSequence);
+  delete (int *)pSequence;
+  return obj;
+}
+}
+
+%fragment(SWIG_AsVal_SequenceItem_frag(bool), "header") {
+
+SWIGINTERN bool
+SWIG_AsVal_SequenceItem_dec(bool)(SwigSciObject obj, int *pSequence, int iItemIndex) {
+  return (bool) pSequence[iItemIndex];
+}
+}
+
+%fragment(SWIG_From_SequenceItem_frag(bool), "header") {
+
+SWIGINTERN int
+SWIG_From_SequenceItem_dec(bool)(int *pSequence, int iItemIndex, bool itemValue) {
+  pSequence[iItemIndex] = itemValue;
+  return SWIG_OK;
+}
+}
diff --git a/share/swig/3.0.12/scilab/scisequencedouble.swg b/share/swig/3.0.12/scilab/scisequencedouble.swg
new file mode 100644
index 0000000..29cc52d
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scisequencedouble.swg
@@ -0,0 +1,99 @@
+/*
+ *
+ * Scilab matrix of double <-> C++ double container
+ *
+ */
+
+%include <scidouble.swg>
+
+%fragment(SWIG_AsCheck_Sequence_frag(double), "header") {
+
+SWIGINTERN int
+SWIG_AsCheck_Sequence_dec(double)(SwigSciObject obj) {
+  SciErr sciErr;
+  int *piAddrVar;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, obj, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (isDoubleType(pvApiCtx, piAddrVar)) {
+    return SWIG_OK;
+  }
+  else {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A double is expected.\n"), SWIG_Scilab_GetFuncName(), obj);
+    return SWIG_ERROR;
+  }
+}
+}
+
+%fragment(SWIG_AsGet_Sequence_frag(double), "header",
+  fragment="SWIG_SciDouble_AsDoubleArrayAndSize") {
+
+SWIGINTERN int
+SWIG_AsGet_Sequence_dec(double)(SwigSciObject obj, double **pSequence) {
+  int iMatrixRowCount;
+  int iMatrixColCount;
+  return (SWIG_SciDouble_AsDoubleArrayAndSize(pvApiCtx, obj, &iMatrixRowCount, &iMatrixColCount, pSequence, SWIG_Scilab_GetFuncName()));
+}
+}
+
+%fragment(SWIG_AsSize_Sequence_frag(double), "header",
+  fragment="SWIG_SciDouble_AsDoubleArrayAndSize") {
+
+SWIGINTERN int
+SWIG_AsSize_Sequence_dec(double)(SwigSciObject obj, int *piSize) {
+  double *pdblMatrix;
+  int iMatrixRowCount;
+  int iMatrixColCount;
+  if (SWIG_SciDouble_AsDoubleArrayAndSize(pvApiCtx, obj, &iMatrixRowCount, &iMatrixColCount, &pdblMatrix, SWIG_Scilab_GetFuncName()) == SWIG_OK) {
+    if ((iMatrixRowCount > 1) && (iMatrixColCount > 1)) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong size for input argument #%d: A double vector is expected.\n"), SWIG_Scilab_GetFuncName(), obj);
+      return SWIG_ERROR;
+    }
+    *piSize = iMatrixRowCount * iMatrixColCount;
+    return SWIG_OK;
+  }
+  return SWIG_ERROR;
+}
+}
+
+%fragment(SWIG_FromCreate_Sequence_frag(double), "header") {
+
+SWIGINTERN int
+SWIG_FromCreate_Sequence_dec(double)(int size, double **pSequence) {
+  *pSequence = new double[size];
+  return *pSequence != NULL ? SWIG_OK : SWIG_ERROR;
+}
+}
+
+%fragment(SWIG_FromSet_Sequence_frag(double), "header",
+  fragment="SWIG_SciDouble_FromDoubleArrayAndSize") {
+
+SWIGINTERN SwigSciObject
+SWIG_FromSet_Sequence_dec(double)(int size, double *pSequence) {
+  SwigSciObject obj = SWIG_SciDouble_FromDoubleArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, size, pSequence);
+  delete (double *)pSequence;
+  return obj;
+}
+}
+
+%fragment(SWIG_AsVal_SequenceItem_frag(double), "header") {
+
+SWIGINTERN double
+SWIG_AsVal_SequenceItem_dec(double)(SwigSciObject obj, double *pSequence, int iItemIndex) {
+  return pSequence[iItemIndex];
+}
+}
+
+%fragment(SWIG_From_SequenceItem_frag(double), "header") {
+
+SWIGINTERN int
+SWIG_From_SequenceItem_dec(double)(double *pSequence, int iItemIndex, double itemValue) {
+  pSequence[iItemIndex] = itemValue;
+  return SWIG_OK;
+}
+}
+
diff --git a/share/swig/3.0.12/scilab/scisequencefloat.swg b/share/swig/3.0.12/scilab/scisequencefloat.swg
new file mode 100644
index 0000000..41d37e5
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scisequencefloat.swg
@@ -0,0 +1,98 @@
+/*
+ *
+ * Scilab matrix of float <-> C++ float container
+ *
+ */
+
+%include <scifloat.swg>
+
+%fragment(SWIG_AsCheck_Sequence_frag(float), "header") {
+
+SWIGINTERN int
+SWIG_AsCheck_Sequence_dec(float)(SwigSciObject obj) {
+  SciErr sciErr;
+  int *piAddrVar;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, obj, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (isDoubleType(pvApiCtx, piAddrVar)) {
+    return SWIG_OK;
+  }
+  else {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A double is expected.\n"), SWIG_Scilab_GetFuncName(), obj);
+    return SWIG_ERROR;
+  }
+}
+}
+
+%fragment(SWIG_AsGet_Sequence_frag(float), "header",
+  fragment="SWIG_SciDouble_AsFloatArrayAndSize") {
+
+SWIGINTERN int
+SWIG_AsGet_Sequence_dec(float)(SwigSciObject obj, float **pSequence) {
+  int iMatrixRowCount;
+  int iMatrixColCount;
+  return (SWIG_SciDouble_AsFloatArrayAndSize(pvApiCtx, obj, &iMatrixRowCount, &iMatrixColCount, pSequence, SWIG_Scilab_GetFuncName()));
+}
+}
+
+%fragment(SWIG_AsSize_Sequence_frag(float), "header",
+  fragment="SWIG_SciDouble_AsFloatArrayAndSize") {
+
+SWIGINTERN int
+SWIG_AsSize_Sequence_dec(float)(SwigSciObject obj, int *piSize) {
+  float *pdblMatrix;
+  int iMatrixRowCount;
+  int iMatrixColCount;
+  if (SWIG_SciDouble_AsFloatArrayAndSize(pvApiCtx, obj, &iMatrixRowCount, &iMatrixColCount, &pdblMatrix, SWIG_Scilab_GetFuncName()) == SWIG_OK) {
+    if ((iMatrixRowCount > 1) && (iMatrixColCount > 1)) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong size for input argument #%d: A float vector is expected.\n"), SWIG_Scilab_GetFuncName(), obj);
+      return SWIG_ERROR;
+    }
+    *piSize = iMatrixRowCount * iMatrixColCount;
+    return SWIG_OK;
+  }
+  return SWIG_ERROR;
+}
+}
+
+%fragment(SWIG_FromCreate_Sequence_frag(float), "header") {
+
+SWIGINTERN int
+SWIG_FromCreate_Sequence_dec(float)(int size, float **pSequence) {
+  *pSequence = new float[size];
+  return *pSequence != NULL ? SWIG_OK : SWIG_ERROR;
+}
+}
+
+%fragment(SWIG_FromSet_Sequence_frag(float), "header",
+  fragment="SWIG_SciDouble_FromFloatArrayAndSize") {
+
+SWIGINTERN SwigSciObject
+SWIG_FromSet_Sequence_dec(float)(int size, float *pSequence) {
+  SwigSciObject obj = SWIG_SciDouble_FromFloatArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, size, pSequence);
+  delete (float *)pSequence;
+  return obj;
+}
+}
+
+%fragment(SWIG_AsVal_SequenceItem_frag(float), "header") {
+
+SWIGINTERN float
+SWIG_AsVal_SequenceItem_dec(float)(SwigSciObject obj, float *pSequence, int iItemIndex) {
+  return pSequence[iItemIndex];
+}
+}
+
+%fragment(SWIG_From_SequenceItem_frag(float), "header") {
+SWIGINTERN int
+SWIG_From_SequenceItem_dec(float)(float *pSequence, int iItemIndex, float itemValue) {
+  pSequence[iItemIndex] = itemValue;
+  return SWIG_OK;
+}
+}
+
diff --git a/share/swig/3.0.12/scilab/scisequenceint.swg b/share/swig/3.0.12/scilab/scisequenceint.swg
new file mode 100644
index 0000000..3a9f7bf
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scisequenceint.swg
@@ -0,0 +1,104 @@
+/*
+ *
+ * Scilab matrix of int <-> C++ int container
+ *
+ */
+
+%include <sciint.swg>
+
+%fragment(SWIG_AsCheck_Sequence_frag(int), "header") {
+
+SWIGINTERN int
+SWIG_AsCheck_Sequence_dec(int)(SwigSciObject obj) {
+  SciErr sciErr;
+  int *piAddrVar;
+  int iType = 0;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, obj, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  sciErr = getVarType(pvApiCtx, piAddrVar, &iType);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if ((iType == sci_matrix) || (iType == sci_ints)) {
+    return SWIG_OK;
+  }
+  else {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: An integer is expected.\n"), SWIG_Scilab_GetFuncName(), obj);
+    return SWIG_ERROR;
+  }
+}
+}
+
+%fragment(SWIG_AsGet_Sequence_frag(int), "header",
+  fragment="SWIG_SciDoubleOrInt32_AsIntArrayAndSize") {
+SWIGINTERN int
+SWIG_AsGet_Sequence_dec(int)(SwigSciObject obj, int **pSequence) {
+  int iMatrixRowCount;
+  int iMatrixColCount;
+  return (SWIG_SciDoubleOrInt32_AsIntArrayAndSize(pvApiCtx, obj, &iMatrixRowCount, &iMatrixColCount, pSequence, SWIG_Scilab_GetFuncName()));
+}
+}
+
+%fragment(SWIG_AsSize_Sequence_frag(int), "header",
+  fragment="SWIG_SciDoubleOrInt32_AsIntArrayAndSize") {
+
+SWIGINTERN int
+SWIG_AsSize_Sequence_dec(int)(SwigSciObject obj, int *piSize) {
+  int *piMatrix;
+  int iMatrixRowCount;
+  int iMatrixColCount;
+  if (SWIG_SciDoubleOrInt32_AsIntArrayAndSize(pvApiCtx, obj, &iMatrixRowCount, &iMatrixColCount, &piMatrix, SWIG_Scilab_GetFuncName()) == SWIG_OK) {
+    if ((iMatrixRowCount > 1) && (iMatrixColCount > 1)) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong size for input argument #%d: An integer vector is expected.\n"), SWIG_Scilab_GetFuncName(), obj);
+      return SWIG_ERROR;
+    }
+    *piSize = iMatrixRowCount * iMatrixColCount;
+    return SWIG_OK;
+  }
+  return SWIG_ERROR;
+}
+}
+
+%fragment(SWIG_FromCreate_Sequence_frag(int), "header") {
+
+SWIGINTERN int
+SWIG_FromCreate_Sequence_dec(int)(int size, int **pSequence) {
+  *pSequence = new int[size];
+  return *pSequence != NULL ? SWIG_OK : SWIG_ERROR;
+}
+}
+
+%fragment(SWIG_FromSet_Sequence_frag(int), "header",
+  fragment="SWIG_SciDouble_FromIntArrayAndSize") {
+
+SWIGINTERN SwigSciObject
+SWIG_FromSet_Sequence_dec(int)(int size, int *pSequence) {
+  SwigSciObject obj = SWIG_SciDouble_FromIntArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, size, pSequence);
+  delete (int *)pSequence;
+  return obj;
+}
+}
+
+%fragment(SWIG_AsVal_SequenceItem_frag(int), "header") {
+
+SWIGINTERN int
+SWIG_AsVal_SequenceItem_dec(int)(SwigSciObject obj, int *pSequence, int iItemIndex) {
+  return pSequence[iItemIndex];
+}
+}
+
+%fragment(SWIG_From_SequenceItem_frag(int), "header") {
+
+SWIGINTERN int
+SWIG_From_SequenceItem_dec(int)(int *pSequence, int iItemIndex, int itemValue) {
+  pSequence[iItemIndex] = itemValue;
+  return SWIG_OK;
+}
+}
diff --git a/share/swig/3.0.12/scilab/scisequencepointer.swg b/share/swig/3.0.12/scilab/scisequencepointer.swg
new file mode 100644
index 0000000..b3618e9
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scisequencepointer.swg
@@ -0,0 +1,123 @@
+/*
+ *
+ * Scilab list of pointer <-> C++ pointer container
+ *
+ */
+
+%include <scilist.swg>
+
+%fragment("<stdint.h>", "header") {
+%#include <stdint.h>
+}
+
+%fragment(SWIG_AsCheck_Sequence_frag(ptr), "header",
+  fragment="SWIG_ScilabList") {
+
+SWIGINTERN int
+SWIG_AsCheck_Sequence_dec(ptr)(SwigSciObject obj) {
+  return SWIG_CheckScilabList(obj);
+}
+}
+
+%fragment(SWIG_AsGet_Sequence_frag(ptr), "header",
+  fragment="SWIG_ScilabList") {
+
+SWIGINTERN int
+SWIG_AsGet_Sequence_dec(ptr)(SwigSciObject obj, int **piSequence) {
+  return SWIG_GetScilabList(obj, piSequence);
+}
+}
+
+%fragment(SWIG_AsSize_Sequence_frag(ptr), "header",
+  fragment="SWIG_ScilabList") {
+
+SWIGINTERN int
+SWIG_AsSize_Sequence_dec(ptr)(SwigSciObject obj, int *piSize) {
+  return SWIG_GetScilabListSize(obj, piSize);
+}
+}
+
+%fragment(SWIG_FromCreate_Sequence_frag(ptr), "header",
+  fragment="<stdint.h>") {
+
+SWIGINTERN int
+SWIG_FromCreate_Sequence_dec(ptr)(int size, uintptr_t **pSequence) {
+  *pSequence = new uintptr_t[size];
+  return *pSequence != NULL ? SWIG_OK : SWIG_ERROR;
+}
+}
+
+%fragment(SWIG_FromSet_Sequence_frag(ptr), "header",
+  fragment="<stdint.h>") {
+
+SWIGINTERN SwigSciObject
+SWIG_FromSet_Sequence_dec(ptr)(int size, uintptr_t *pSequence) {
+  SciErr sciErr;
+  int *piListAddr;
+
+  int iVarOut = SWIG_NbInputArgument(pvApiCtx) + SWIG_Scilab_GetOutputPosition();
+
+  sciErr = createList(pvApiCtx, iVarOut, size, &piListAddr);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  for (int i=0; i<size; i++) {
+    sciErr = createPointerInList(pvApiCtx, iVarOut, piListAddr, i + 1, (void *)pSequence[i]);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+  }
+  delete (int*)pSequence;
+  return SWIG_OK;
+}
+}
+
+%fragment(SWIG_AsVal_SequenceItem_frag(ptr), "header") {
+
+SWIGINTERN void*
+SWIG_AsVal_SequenceItem_dec(ptr)(SwigSciObject obj, int *piSequence, int itemIndex)
+{
+  SciErr sciErr;
+  int *piItemAddr;
+  int iType;
+  void* pItemValue = NULL;
+
+  sciErr = getListItemAddress(pvApiCtx, piSequence, itemIndex + 1, &piItemAddr);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return NULL;
+  }
+
+  sciErr = getVarType(pvApiCtx, piItemAddr, &iType);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return NULL;
+  }
+
+  if (iType != sci_pointer) {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A pointer is expected at list item #%d.\n"), SWIG_Scilab_GetFuncName(), obj, itemIndex + 1);
+    return NULL;
+  }
+
+  sciErr = getPointerInList(pvApiCtx, piSequence, itemIndex + 1, &pItemValue);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return NULL;
+  }
+
+  return pItemValue;
+}
+}
+
+%fragment(SWIG_From_SequenceItem_frag(ptr), "header",
+  fragment="<stdint.h>") {
+
+SWIGINTERN int
+SWIG_From_SequenceItem_dec(ptr)(uintptr_t *pSequence, int iItemIndex, uintptr_t itemValue) {
+  pSequence[iItemIndex] = itemValue;
+  return SWIG_OK;
+}
+}
diff --git a/share/swig/3.0.12/scilab/scisequencestring.swg b/share/swig/3.0.12/scilab/scisequencestring.swg
new file mode 100644
index 0000000..d3c05e4
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scisequencestring.swg
@@ -0,0 +1,97 @@
+/*
+ *
+ * Scilab matrix of string <-> C++ std::string container
+ *
+ */
+
+%include <scichar.swg>
+
+%fragment(SWIG_AsCheck_Sequence_frag(std::string), "header") {
+
+SWIGINTERN int
+SWIG_AsCheck_Sequence_dec(std::string)(SwigSciObject obj) {
+  SciErr sciErr;
+  int *piAddrVar;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, obj, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (isStringType(pvApiCtx, piAddrVar)) {
+    return SWIG_OK;
+  }
+  else {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A string is expected.\n"), SWIG_Scilab_GetFuncName(), obj);
+    return SWIG_ERROR;
+  }
+}
+}
+
+%fragment(SWIG_AsGet_Sequence_frag(std::string), "header",
+  fragment="SWIG_SciString_AsCharPtrArrayAndSize") {
+
+SWIGINTERN int
+SWIG_AsGet_Sequence_dec(std::string)(SwigSciObject obj, char ***pSequence) {
+  int iRows = 0;
+  int iCols = 0;
+  return (SWIG_SciString_AsCharPtrArrayAndSize(pvApiCtx, obj, &iRows, &iCols, pSequence, SWIG_Scilab_GetFuncName()));
+}
+}
+
+%fragment(SWIG_AsSize_Sequence_frag(std::string), "header",
+  fragment="SWIG_SciString_AsCharPtrArrayAndSize") {
+
+SWIGINTERN int
+SWIG_AsSize_Sequence_dec(std::string)(SwigSciObject obj, int *piSize) {
+  char **pstMatrix;
+  int iCols = 0;
+  int iRows = 0;
+  if (SWIG_SciString_AsCharPtrArrayAndSize(pvApiCtx, obj, &iRows, &iCols, &pstMatrix, SWIG_Scilab_GetFuncName()) == SWIG_OK) {
+    *piSize = iRows * iCols;
+    return SWIG_OK;
+  }
+  return SWIG_ERROR;
+}
+}
+
+%fragment(SWIG_FromCreate_Sequence_frag(std::string), "header") {
+
+SWIGINTERN int
+SWIG_FromCreate_Sequence_dec(std::string)(int size, char ***pSequence) {
+  *pSequence = new char*[size];
+  return *pSequence != NULL ? SWIG_OK : SWIG_ERROR;
+}
+}
+
+%fragment(SWIG_FromSet_Sequence_frag(std::string), "header",
+  fragment="SWIG_SciString_FromCharPtrArrayAndSize") {
+
+SWIGINTERN SwigSciObject
+SWIG_FromSet_Sequence_dec(std::string)(int size, char **pSequence) {
+  SwigSciObject obj = SWIG_SciString_FromCharPtrArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, size, pSequence);
+  delete (char **)pSequence;
+  return obj;
+}
+}
+
+%fragment(SWIG_AsVal_SequenceItem_frag(std::string), "header") {
+
+SWIGINTERN std::string
+SWIG_AsVal_SequenceItem_dec(std::string)(SwigSciObject obj, char **pSequence, int iItemIndex) {
+  return std::string(pSequence[iItemIndex]);
+}
+}
+
+%fragment(SWIG_From_SequenceItem_frag(std::string), "header") {
+
+SWIGINTERN int
+SWIG_From_SequenceItem_dec(std::string)(char **pSequence, int iItemIndex, std::string itemValue) {
+  char *pChar = new char((int) itemValue.size() + 1);
+  strcpy(pChar, itemValue.c_str());
+  pSequence[iItemIndex] = pChar;
+  return SWIG_OK;
+}
+}
+
diff --git a/share/swig/3.0.12/scilab/scishort.swg b/share/swig/3.0.12/scilab/scishort.swg
new file mode 100644
index 0000000..3d2f0f9
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scishort.swg
@@ -0,0 +1,188 @@
+/*
+ * C-type: short
+ * Scilab type: double or int16
+ */
+
+%fragment(SWIG_AsVal_frag(short), "header", fragment="SWIG_SciDoubleOrInt16_AsShort", fragment="<limits.h>") {
+#define SWIG_AsVal_short(scilabValue, valuePointer) SWIG_SciDoubleOrInt16_AsShort(pvApiCtx, scilabValue, valuePointer, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_SciDoubleOrInt16_AsShort", "header") {
+SWIGINTERN int
+SWIG_SciDoubleOrInt16_AsShort(void *pvApiCtx, int iVar, short *psValue, char *fname) {
+  SciErr sciErr;
+  int iType = 0;
+  int iRows = 0;
+  int iCols = 0;
+  int *piAddrVar = NULL;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  sciErr = getVarType(pvApiCtx, piAddrVar, &iType);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (iType == sci_ints) {
+    int iPrec = 0;
+    short *psData = NULL;
+
+    sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddrVar, &iPrec);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+    if (iPrec != SCI_INT16) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 16-bit signed integer or a double expected.\n"), fname, iVar);
+      return SWIG_TypeError;
+    }
+    sciErr = getMatrixOfInteger16(pvApiCtx, piAddrVar, &iRows, &iCols, &psData);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+    if (iRows * iCols != 1) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong size for input argument #%d: A 16-bit signed integer or a double expected.\n"), fname, iVar);
+      return SWIG_TypeError;
+    }
+    *psValue = *psData;
+  }
+  else if (iType == sci_matrix) {
+    double *pdData = NULL;
+    double dValue = 0.0f;
+
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrVar, &iRows, &iCols, &pdData);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+    if (iRows * iCols != 1) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong size for input argument #%d: A 16-bit signed integer or a double expected.\n"), fname, iVar);
+      return SWIG_TypeError;
+    }
+    dValue = *pdData;
+    if (dValue != floor(dValue)) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 16-bit signed integer.\n"), fname, iVar);
+      return SWIG_ValueError;
+    }
+    if ((dValue < SHRT_MIN) || (dValue > SHRT_MAX)) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 16-bit signed integer.\n"), fname, iVar);
+      return SWIG_OverflowError;
+    }
+    *psValue = (short) dValue;
+  }
+  else {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 16-bit signed integer or a double expected.\n"), fname, iVar);
+    return SWIG_TypeError;
+  }
+
+  return SWIG_OK;
+}
+}
+
+%fragment(SWIG_From_frag(short), "header", fragment="SWIG_SciDouble_FromShort") {
+#define SWIG_From_short(scilabValue) SWIG_SciDouble_FromShort(pvApiCtx, SWIG_Scilab_GetOutputPosition(), scilabValue, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_SciDouble_FromShort", "header") {
+SWIGINTERN int
+SWIG_SciDouble_FromShort(void *pvApiCtx, int iVarOut, short sValue, char *fname) {
+  if (createScalarDouble(pvApiCtx,
+    SWIG_NbInputArgument(pvApiCtx) + iVarOut, (double) sValue))
+    return SWIG_ERROR;
+  return SWIG_OK;
+}
+}
+
+/*
+ * C-type: short[]
+ * Scilab type: double or int16 matrix
+ */
+%fragment("SWIG_SciDoubleOrInt16_AsShortArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciDoubleOrInt16_AsShortArrayAndSize(void *pvApiCtx, int iVar, int *iRows, int *iCols, short **psValue, char *fname) {
+  SciErr sciErr;
+  int iType = 0;
+  int iPrec = 0;
+  int *piAddrVar = NULL;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  sciErr = getVarType(pvApiCtx, piAddrVar, &iType);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (iType == sci_matrix) {
+    double *pdData = NULL;
+    int size = 0;
+    int i;
+
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrVar, iRows, iCols, &pdData);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+
+    size = (*iRows) * (*iCols);
+    *psValue = (short*) malloc(size * sizeof(int*));
+    for (i = 0; i < size; i++)
+      (*psValue)[i] = (short) pdData[i];
+  }
+  else if (iType == sci_ints) {
+    int iPrec = 0;
+    sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddrVar, &iPrec);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+    if (iPrec != SCI_INT16) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 16-bit signed integer or a double matrix expected.\n"), fname, iVar);
+      return SWIG_ERROR;
+    }
+
+    sciErr = getMatrixOfInteger16(pvApiCtx, piAddrVar, iRows, iCols, psValue);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+  }
+  else {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 16-bit signed integer or a double matrix expected.\n"), fname, iVar);
+    return SWIG_ERROR;
+  }
+
+  return SWIG_OK;
+}
+}
+%fragment("SWIG_SciDouble_FromShortArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciDouble_FromShortArrayAndSize(void *pvApiCtx, int iVarOut, int iRows, int iCols, short *psValue) {
+  SciErr sciErr;
+  int i;
+  double *pdValues = NULL;
+
+  pdValues = (double*) malloc(iRows * iCols * sizeof(double));
+  for (i=0; i<iRows * iCols; i++)
+    pdValues[i] = psValue[i];
+
+  sciErr = createMatrixOfDouble(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, iRows, iCols, pdValues);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    free(pdValues);
+    return SWIG_ERROR;
+  }
+
+  free(pdValues);
+  return SWIG_OK;
+}
+}
+
diff --git a/share/swig/3.0.12/scilab/scisignedchar.swg b/share/swig/3.0.12/scilab/scisignedchar.swg
new file mode 100644
index 0000000..c2350b0
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scisignedchar.swg
@@ -0,0 +1,185 @@
+/*
+ * C-type: signed char
+ * Scilab type: double or int8
+ */
+%fragment(SWIG_AsVal_frag(signed char), "header", fragment="SWIG_SciDoubleOrInt8_AsSignedChar", fragment="<limits.h>") {
+#define SWIG_AsVal_signed_SS_char(scilabValue, valuePointer) SWIG_SciDoubleOrInt8_AsSignedChar(pvApiCtx, scilabValue, valuePointer, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_SciDoubleOrInt8_AsSignedChar", "header") {
+SWIGINTERN int
+SWIG_SciDoubleOrInt8_AsSignedChar(void *pvApiCtx, int iVar, signed char *pscValue, char *fname) {
+  SciErr sciErr;
+  int iType = 0;
+  int iRows = 0;
+  int iCols = 0;
+  int iPrec = 0;
+  int *piAddrVar = NULL;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  sciErr = getVarType(pvApiCtx, piAddrVar, &iType);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (iType == sci_ints) {
+    char *pcData = NULL;
+
+    sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddrVar, &iPrec);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+    if (iPrec != SCI_INT8) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 8-bit signed integer or a double expected.\n"), fname, iVar);
+      return SWIG_TypeError;
+    }
+    sciErr = getMatrixOfInteger8(pvApiCtx, piAddrVar, &iRows, &iCols, &pcData);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+    if (iRows * iCols != 1) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong size for input argument #%d: A 8-bit signed integer or a double expected.\n"), fname, iVar);
+      return SWIG_TypeError;
+    }
+    *pscValue = *pcData;
+  }
+  else if (iType == sci_matrix) {
+    double *pdData = NULL;
+    double dValue = 0.0f;
+
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrVar, &iRows, &iCols, &pdData);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+    if (iRows * iCols != 1) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong size for input argument #%d: A 8-bit signed integer or a double expected.\n"), fname, iVar);
+      return SWIG_TypeError;
+    }
+    dValue = *pdData;
+    if (dValue != floor(dValue)) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 8-bit signed integer.\n"), fname, iVar);
+      return SWIG_ValueError;
+    }
+    if ((dValue < SCHAR_MIN) || (dValue > SCHAR_MAX)) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 8-bit signed integer.\n"), fname, iVar);
+      return SWIG_OverflowError;
+    }
+    *pscValue = (signed char) dValue;
+  }
+  else {
+     Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 8-bit signed integer or a double expected.\n"), fname, iVar);
+    return SWIG_TypeError;
+  }
+
+  return SWIG_OK;
+}
+}
+
+%fragment(SWIG_From_frag(signed char), "header", fragment="SWIG_SciDouble_FromSignedChar") {
+#define SWIG_From_signed_SS_char(scilabValue) SWIG_SciDouble_FromSignedChar(pvApiCtx, SWIG_Scilab_GetOutputPosition(), scilabValue)
+}
+%fragment("SWIG_SciDouble_FromSignedChar", "header") {
+SWIGINTERN int
+SWIG_SciDouble_FromSignedChar(void *pvApiCtx, int iVarOut, signed char scValue) {
+  if (createScalarDouble(pvApiCtx,
+    SWIG_NbInputArgument(pvApiCtx) + iVarOut, (double) scValue))
+    return SWIG_ERROR;
+  return SWIG_OK;
+}
+}
+
+/*
+ * C-type: signed char[]
+ * Scilab type: double or int8 matrix
+ */
+%fragment("SWIG_SciDoubleOrInt8_AsSignedCharArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciDoubleOrInt8_AsSignedCharArrayAndSize(void *pvApiCtx, int iVar, int *iRows, int *iCols, signed char **pscValue, char *fname) {
+  SciErr sciErr;
+  int iType = 0;
+  int *piAddrVar = NULL;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  sciErr = getVarType(pvApiCtx, piAddrVar, &iType);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (iType == sci_matrix) {
+    double *pdData = NULL;
+    int size = 0;
+    int i;
+
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrVar, iRows, iCols, &pdData);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+
+    size = (*iRows) * (*iCols);
+    *pscValue = (signed char*) malloc(size * sizeof(int*));
+    for (i = 0; i < size; i++)
+      (*pscValue)[i] = (signed char) pdData[i];
+  }
+  else if (iType == sci_ints) {
+    int iPrec = 0;
+    sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddrVar, &iPrec);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+    if (iPrec != SCI_INT8) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 8-bit signed integer or a double matrix expected.\n"), fname, iVar);
+      return SWIG_ERROR;
+    }
+
+    sciErr = getMatrixOfInteger8(pvApiCtx, piAddrVar, iRows, iCols, (char **)pscValue);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+  }
+  else {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 8-bit signed integer or a double matrix expected.\n"), fname, iVar);
+    return SWIG_ERROR;
+  }
+  return SWIG_OK;
+}
+}
+
+%fragment("SWIG_SciDouble_FromSignedCharArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciDouble_FromSignedCharArrayAndSize(void *pvApiCtx, int iVarOut, int iRows, int iCols, const signed char *pscValue) {
+  SciErr sciErr;
+  int i;
+  double *pdValues = NULL;
+
+  pdValues = (double*) malloc(iRows * iCols * sizeof(double));
+  for (i=0; i<iRows * iCols; i++)
+    pdValues[i] = pscValue[i];
+
+  sciErr = createMatrixOfDouble(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, iRows, iCols, pdValues);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    free(pdValues);
+    return SWIG_ERROR;
+  }
+
+  free(pdValues);
+  return SWIG_OK;
+}
+}
diff --git a/share/swig/3.0.12/scilab/scistdcommon.swg b/share/swig/3.0.12/scilab/scistdcommon.swg
new file mode 100644
index 0000000..63f3ca1
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scistdcommon.swg
@@ -0,0 +1,227 @@
+%fragment("StdTraits","header",fragment="StdTraitsCommon")
+{
+namespace swig {
+// Traits that provides the from method
+  template <class Type> struct traits_from_ptr {
+    static SwigSciObject from(Type *val, int owner = 0) {
+        return SWIG_OK; //SWIG_NewPointerObj(val, type_info<Type>(), owner);
+    }
+  };
+
+  template <class Type> struct traits_from {
+    static SwigSciObject from(const Type& val) {
+      return traits_from_ptr<Type>::from(new Type(val), 1);
+    }
+  };
+
+  template <class Type> struct traits_from<Type *> {
+    static SwigSciObject from(Type* val) {
+      return traits_from_ptr<Type>::from(val, 0);
+    }
+  };
+
+  template <class Type> struct traits_from<const Type *> {
+    static SwigSciObject from(const Type* val) {
+      return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
+    }
+  };
+
+
+  template <class Type>
+  inline SwigSciObject from(const Type& val) {
+    return traits_from<Type>::from(val);
+  }
+
+  template <class Type>
+  inline SwigSciObject from_ptr(Type* val, int owner) {
+    return traits_from_ptr<Type>::from(val, owner);
+  }
+
+    // Traits that provides the asval/as/check method
+  template <class Type>
+  struct traits_asptr {
+    static int asptr(const SwigSciObject& obj, Type **val) {
+      Type *p;
+      swig_type_info *descriptor = type_info<Type>();
+      int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
+      if (SWIG_IsOK(res)) {
+	if (val) *val = p;
+      }
+      return res;
+    }
+  };
+
+  template <class Type>
+  inline int asptr(const SwigSciObject& obj, Type **vptr) {
+    return traits_asptr<Type>::asptr(obj, vptr);
+  }
+
+  template <class Type>
+  struct traits_asval {
+    static int asval(const SwigSciObject& obj, Type *val) {
+      if (val) {
+	Type *p = 0;
+	int res = traits_asptr<Type>::asptr(obj, &p);
+	if (!SWIG_IsOK(res))
+    return res;
+	if (p) {
+	  typedef typename noconst_traits<Type>::noconst_type noconst_type;
+	  *(const_cast<noconst_type*>(val)) = *p;
+	  if (SWIG_IsNewObj(res)){
+	    %delete(p);
+	    res = SWIG_DelNewMask(res);
+	  }
+	  return res;
+	} else {
+	  return SWIG_ERROR;
+	}
+      } else {
+	return traits_asptr<Type>::asptr(obj, (Type **)(0));
+      }
+    }
+  };
+
+  template <class Type> struct traits_asval<Type*> {
+    static int asval(const SwigSciObject& obj, Type **val) {
+      if (val) {
+        typedef typename noconst_traits<Type>::noconst_type noconst_type;
+        noconst_type *p = 0;
+        int res = traits_asptr<noconst_type>::asptr(obj,  &p);
+        if (SWIG_IsOK(res)) {
+          *(const_cast<noconst_type**>(val)) = p;
+	}
+	return res;
+      } else {
+	return traits_asptr<Type>::asptr(obj, (Type **)(0));
+      }
+    }
+  };
+
+  template <class Type>
+  inline int asval(const SwigSciObject& obj, Type *val) {
+    return traits_asval<Type>::asval(obj, val);
+  }
+
+  template <class Type>
+  struct traits_as<Type, value_category> {
+    static Type as(const SwigSciObject& obj, bool throw_error) {
+      Type v;
+      int res = asval(obj, &v);
+      if (SWIG_IsOK(res)) {
+        return v;
+      } else {
+	      %type_error(swig::type_name<Type>());
+	      if (throw_error)
+          throw std::invalid_argument("bad type");
+        return res;
+      }
+    }
+  };
+
+  template <class Type>
+  struct traits_as<Type, pointer_category> {
+    static Type as(const SwigSciObject& obj, bool throw_error) {
+      Type *v = 0;
+      int res = traits_asptr<Type>::asptr(obj, &v);
+      if (SWIG_IsOK(res) && v) {
+	if (SWIG_IsNewObj(res)) {
+	  Type r(*v);
+	  %delete(v);
+	  return r;
+	} else {
+	  return *v;
+	}
+      } else {
+	// Uninitialized return value, no Type() constructor required.
+	static Type *v_def = (Type*) malloc(sizeof(Type));
+  %type_error(swig::type_name<Type>());
+	if (throw_error)
+    throw std::invalid_argument("bad type");
+	memset(v_def,0,sizeof(Type));
+	return *v_def;
+      }
+    }
+  };
+
+  template <class Type>
+  struct traits_as<Type*, pointer_category> {
+    static Type* as(const SwigSciObject& obj, bool throw_error) {
+      Type *v = 0;
+      int res = traits_asptr<Type>::asptr(obj, &v);
+      if (SWIG_IsOK(res)) {
+	return v;
+      } else {
+  %type_error(swig::type_name<Type>());
+	if (throw_error)
+    throw std::invalid_argument("bad type");
+	return SWIG_OK;
+      }
+    }
+  };
+
+  template <class Type>
+  inline Type as(const SwigSciObject& obj, bool te = false) {
+    return traits_as<Type, typename traits<Type>::category>::as(obj, te);
+  }
+
+  template <class Type>
+  struct traits_check<Type, value_category> {
+    static bool check(const SwigSciObject& obj) {
+      int res = asval(obj, (Type *)(0));
+      return SWIG_IsOK(res) ? true : false;
+    }
+  };
+
+  template <class Type>
+  struct traits_check<Type, pointer_category> {
+    static bool check(const SwigSciObject& obj) {
+      int res = asptr(obj, (Type **)(0));
+      return SWIG_IsOK(res) ? true : false;
+    }
+  };
+
+  template <class Type>
+  inline bool check(const SwigSciObject& obj) {
+    return traits_check<Type, typename traits<Type>::category>::check(obj);
+  }
+}
+}
+
+%define %specialize_std_container(Type,Check,As,From)
+%{
+namespace swig {
+  template <>  struct traits_asval<Type > {
+    typedef Type value_type;
+    static int asval(const SwigSciObject& obj, value_type *val) {
+      if (Check(obj)) {
+	if (val) *val = As(obj);
+	return SWIG_OK;
+      }
+      return SWIG_ERROR;
+    }
+  };
+  template <>  struct traits_from<Type > {
+    typedef Type value_type;
+    static SwigSciObject from(const value_type& val) {
+      return From(val);
+    }
+  };
+
+  template <>
+  struct traits_check<Type, value_category> {
+    static int check(const SwigSciObject& obj) {
+      int res = Check(obj);
+      return obj && res ? res : 0;
+    }
+  };
+}
+%}
+%enddef
+
+
+#define specialize_std_vector(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
+#define specialize_std_list(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
+#define specialize_std_deque(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
+#define specialize_std_set(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
+#define specialize_std_multiset(Type,Check,As,From) %specialize_std_container(%arg(Type),Check,As,From)
+
diff --git a/share/swig/3.0.12/scilab/scitypemaps.swg b/share/swig/3.0.12/scilab/scitypemaps.swg
new file mode 100644
index 0000000..4cf0da3
--- /dev/null
+++ b/share/swig/3.0.12/scilab/scitypemaps.swg
@@ -0,0 +1,259 @@
+// Scilab fragments for primitive types
+%include <sciprimtypes.swg>
+
+%include <scienum.swg>
+
+// Scilab object type
+#define SWIG_Object int
+
+#define %append_output(obj)         if (!SWIG_IsOK(SWIG_Scilab_SetOutput(pvApiCtx, obj))) return SWIG_ERROR
+#define %set_constant(name, obj)    if (!SWIG_IsOK(SWIG_Scilab_SetOutput(pvApiCtx, obj))) return SWIG_ERROR // Name is managed by the the function name
+#define %raise(obj, type, desc)     SWIG_Scilab_Raise(obj, type, desc)
+#define %set_output(obj)            if (!SWIG_IsOK(SWIG_Scilab_SetOutput(pvApiCtx, obj))) return SWIG_ERROR
+#define %set_varoutput(obj)         if (!SWIG_IsOK(SWIG_Scilab_SetOutput(pvApiCtx, obj))) return SWIG_ERROR
+#define %set_argoutput(obj)         if (!SWIG_IsOK(SWIG_Scilab_SetOutput(pvApiCtx, obj))) return SWIG_ERROR
+
+// Include the unified typemap library
+%include <typemaps/swigtypemaps.swg>
+
+/* ---------------------------------------------------------------------------*/
+/* Generic typmemaps                                                          */
+/*                                                                            */
+/* This typemap is used when Scilab does not store this type directly         */
+/* For example, a 'float' is stored in Scilab as a 'double'                   */
+/* So we read a 'double' in Scilab and cast it to a 'float'                   */
+/* ---------------------------------------------------------------------------*/
+
+%define %scilab_in_typemap_withcast(TYPEMAPTYPE, FRAGMENTNAME, CTYPE, TEMPTYPE, TEMPINIT)
+%typemap(TYPEMAPTYPE, fragment="FRAGMENTNAME") CTYPE {
+  TEMPTYPE tempValue = TEMPINIT;
+  if(FRAGMENTNAME(pvApiCtx, $input, &tempValue, SWIG_Scilab_GetFuncName()) != SWIG_OK) {
+    return SWIG_ERROR;
+  }
+  $1 = (CTYPE) tempValue;
+}
+%enddef
+%define %scilab_inptr_typemap(TYPEMAPTYPE, FRAGMENTNAME, CTYPE)
+%typemap(TYPEMAPTYPE, noblock=1, fragment="FRAGMENTNAME") CTYPE {
+  if (FRAGMENTNAME(pvApiCtx, $input, %as_voidptrptr(&$1), SWIG_Scilab_GetFuncName()) != SWIG_OK) {
+    return SWIG_ERROR;
+  }
+}
+%enddef
+
+%define %scilab_out_typemap(TYPEMAPTYPE, FRAGMENTNAME, CTYPE)
+%typemap(TYPEMAPTYPE, noblock=1, fragment="FRAGMENTNAME") CTYPE {
+  if (FRAGMENTNAME(pvApiCtx, $result, $1) != SWIG_OK) {
+    return SWIG_ERROR;
+  }
+}
+%enddef
+
+%define %scilab_outptr_typemap(TYPEMAPTYPE, FRAGMENTNAME, CTYPE)
+%typemap(TYPEMAPTYPE, noblock=1, fragment="FRAGMENTNAME") CTYPE {
+  if (FRAGMENTNAME(pvApiCtx, $result, %as_voidptr($1)) != SWIG_OK) {
+    return SWIG_ERROR;
+  }
+}
+%enddef
+
+%define %scilab_varout_typemap(TYPEMAPTYPE, FRAGMENTNAME, CTYPE)
+%typemap(TYPEMAPTYPE, noblock=1, fragment="FRAGMENTNAME") CTYPE {
+  if (FRAGMENTNAME(pvApiCtx, $result, $value) != SWIG_OK) {
+    return SWIG_ERROR;
+  }
+}
+%enddef
+
+%define %scilab_varoutptr_typemap(TYPEMAPTYPE, FRAGMENTNAME, CTYPE)
+%typemap(TYPEMAPTYPE, noblock=1, fragment="FRAGMENTNAME") CTYPE {
+  if (FRAGMENTNAME(pvApiCtx, $result, %as_voidptr($value)) != SWIG_OK) {
+    return SWIG_ERROR;
+  }
+}
+%enddef
+
+%define %scilab_in_typemap(TYPEMAPTYPE, FRAGMENTNAME, CTYPE)
+%typemap(TYPEMAPTYPE, noblock=1, fragment="FRAGMENTNAME") CTYPE {
+  if (FRAGMENTNAME(pvApiCtx, $input, &$1, SWIG_Scilab_GetFuncName()) != SWIG_OK) {
+    return SWIG_ERROR;
+  }
+}
+%enddef
+
+
+/* ---------------------------------------------------------------------------*/
+/* Array typmemaps                                                            */
+/* ---------------------------------------------------------------------------*/
+
+%include <sciarray.swg>
+
+
+/* ---------------------------------------------------------------------------*/
+/* Enum typemaps                                                              */
+/* ---------------------------------------------------------------------------*/
+
+%typemap(in, noblock=1, fragment=SWIG_AsVal_frag(Enum)) enum SWIGTYPE (int val) {
+  if (SWIG_AsVal_dec(Enum)($input, &val) != SWIG_OK) {
+    return SWIG_ERROR;
+  }
+  $1 = %reinterpret_cast(val, $ltype);
+}
+
+%typemap(out, fragment=SWIG_From_frag(Enum)) enum SWIGTYPE {
+  if (SWIG_From_dec(Enum)($1) != SWIG_OK) {
+    return SWIG_ERROR;
+  }
+}
+
+/* ---------------------------------------------------------------------------*/
+/* Typecheck typemaps                                                         */
+/* ---------------------------------------------------------------------------*/
+
+%define %scilab_typecheck_generic(PRECEDENCE, TYPE_CHECK_FUNCTION, TYPE)
+%typecheck(PRECEDENCE) TYPE {
+  int *piAddrVar = NULL;
+  SciErr sciErr = getVarAddressFromPosition(pvApiCtx, $input, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+  $1 = TYPE_CHECK_FUNCTION(pvApiCtx, piAddrVar);
+}
+%enddef
+
+%fragment("SWIG_Check_SciDoubleOrInt", "header") {
+SWIGINTERN int
+SWIG_Check_SciDoubleOrInt(void *pvApiCtx, SwigSciObject iVar, int iIntegerType) {
+  int *piAddrVar = NULL;
+  int ret = 0;
+  SciErr sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return 0;
+  }
+  ret = isIntegerType(pvApiCtx, piAddrVar);
+  if (ret == 1) {
+    int iPrec = 0;
+    sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddrVar, &iPrec);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    ret = (iPrec == iIntegerType) ? 1 : 0;
+  }
+  else {
+    ret = isDoubleType(pvApiCtx, piAddrVar);
+  }
+  return ret;
+}
+}
+
+/* Scilab equivalent for C integers can be sci_intXX or sci_matrix */
+%define %scilab_typecheck_integer(PRECEDENCE, INTTYPE, TYPE)
+%typecheck(PRECEDENCE, fragment="SWIG_Check_SciDoubleOrInt") TYPE {
+  $1 = SWIG_Check_SciDoubleOrInt(pvApiCtx, $input, INTTYPE);
+}
+%enddef
+
+%define %scilab_typecheck_pointer(PRECEDENCE, TYPE)
+%typecheck(PRECEDENCE) TYPE {
+  $1 = SwigScilabCheckPtr(pvApiCtx, $input, $descriptor, SWIG_Scilab_GetFuncName());
+}
+%enddef
+
+
+// Double (and Float) have priority over before Integer type.
+
+// Primitive types
+%scilab_typecheck_pointer(SWIG_TYPECHECK_VOIDPTR, SWIGTYPE *)
+%scilab_typecheck_pointer(SWIG_TYPECHECK_POINTER, SWIGTYPE *)
+%scilab_typecheck_generic(SWIG_TYPECHECK_BOOL, isBooleanType,    bool)
+%scilab_typecheck_generic(16, isDoubleType,                      double)
+%scilab_typecheck_generic(17, isDoubleType,                      float)
+%scilab_typecheck_integer(SWIG_TYPECHECK_INT8, SCI_INT8,         signed char)
+%scilab_typecheck_integer(SWIG_TYPECHECK_UINT8, SCI_UINT8,       unsigned char)
+%scilab_typecheck_integer(SWIG_TYPECHECK_INT16, SCI_INT16,       short)
+%scilab_typecheck_integer(SWIG_TYPECHECK_UINT16, SCI_UINT16,     unsigned short)
+%scilab_typecheck_integer(SWIG_TYPECHECK_INT32, SCI_INT32,       int)
+%scilab_typecheck_integer(SWIG_TYPECHECK_INT32, SCI_INT32,       long)
+%scilab_typecheck_integer(SWIG_TYPECHECK_UINT32, SCI_UINT32,     unsigned int)
+%scilab_typecheck_integer(SWIG_TYPECHECK_UINT32, SCI_UINT32,     unsigned long)
+%scilab_typecheck_integer(SWIG_TYPECHECK_INT32, SCI_INT32,       enum SWIGTYPE)
+%scilab_typecheck_generic(SWIG_TYPECHECK_CHAR, isStringType,     char)
+
+// Arrays
+%scilab_typecheck_generic(SWIG_TYPECHECK_BOOL_ARRAY, isBooleanType,  bool)
+%scilab_typecheck_generic(1016, isDoubleType,                        double [ANY])
+%scilab_typecheck_generic(1017, isDoubleType,                        float [ANY])
+%scilab_typecheck_integer(SWIG_TYPECHECK_INT8_ARRAY, SCI_INT8,       signed char [ANY])
+%scilab_typecheck_integer(1026, SCI_UINT8,                           unsigned char [ANY])
+%scilab_typecheck_integer(SWIG_TYPECHECK_INT16_ARRAY, SCI_INT16,     short [ANY])
+%scilab_typecheck_integer(1036, SCI_UINT16,                          unsigned short [ANY])
+%scilab_typecheck_integer(SWIG_TYPECHECK_INT32_ARRAY, SCI_INT32,     int [ANY])
+%scilab_typecheck_integer(SWIG_TYPECHECK_INT32_ARRAY, SCI_INT32,     long [ANY])
+%scilab_typecheck_integer(1046, SCI_UINT32,                          unsigned int [ANY])
+%scilab_typecheck_integer(1046, SCI_UINT32,                          unsigned long [ANY])
+%scilab_typecheck_generic(SWIG_TYPECHECK_CHAR_ARRAY, isStringType,   char [ANY])
+%scilab_typecheck_generic(SWIG_TYPECHECK_STRING_ARRAY, isStringType, char *[ANY])
+%scilab_typecheck_generic(SWIG_TYPECHECK_STRING_ARRAY, isStringType, char **)
+
+
+/* ---------------------------------------------------------------------------*/
+/* %scilabconstcode() feature typemaps                                        */
+/* ---------------------------------------------------------------------------*/
+
+%typemap(scilabconstcode, fragment=SWIG_CreateScilabVariable_frag(double)) double
+%{
+  if (SWIG_CreateScilabVariable_double(pvApiCtx, "$result", $value) != SWIG_OK)
+    return SWIG_ERROR;
+%}
+
+%typemap(scilabconstcode, fragment=SWIG_CreateScilabVariable_frag(int)) int
+%{
+  if (SWIG_CreateScilabVariable_int(pvApiCtx, "$result", $value) != SWIG_OK)
+    return SWIG_ERROR;
+%}
+
+%typemap(scilabconstcode, fragment=SWIG_CreateScilabVariable_frag(uint)) unsigned int
+%{
+  if (SWIG_CreateScilabVariable_uint(pvApiCtx, "$result", $value) != SWIG_OK)
+    return SWIG_ERROR;
+%}
+
+%typemap(scilabconstcode, fragment=SWIG_CreateScilabVariable_frag(int)) long
+%{
+  if (SWIG_CreateScilabVariable_int(pvApiCtx, "$result", $value) != SWIG_OK)
+    return SWIG_ERROR;
+%}
+
+%typemap(scilabconstcode, fragment=SWIG_CreateScilabVariable_frag(uint)) unsigned long
+%{
+  if (SWIG_CreateScilabVariable_uint(pvApiCtx, "$result", $value) != SWIG_OK)
+    return SWIG_ERROR;
+%}
+
+%typemap(scilabconstcode, fragment=SWIG_CreateScilabVariable_frag(char)) char
+%{
+  if (SWIG_CreateScilabVariable_char(pvApiCtx, "$result", $value) != SWIG_OK)
+    return SWIG_ERROR;
+%}
+
+%typemap(scilabconstcode, fragment=SWIG_CreateScilabVariable_frag(charptr)) char *
+%{
+  if (SWIG_CreateScilabVariable_charptr(pvApiCtx, "$result", $value) != SWIG_OK)
+    return SWIG_ERROR;
+%}
+
+%typemap(scilabconstcode, fragment=SWIG_CreateScilabVariable_frag(double)) enum SWIGTYPE
+%{
+  if (SWIG_CreateScilabVariable_double(pvApiCtx, "$result", $value) != SWIG_OK)
+    return SWIG_ERROR;
+%}
+
+
+/* ---------------------------------------------------------------------------*/
+/* Exception typmemaps                                                        */
+/* ---------------------------------------------------------------------------*/
+
+%include <sciexception.swg>
diff --git a/share/swig/3.0.12/scilab/sciunsignedchar.swg b/share/swig/3.0.12/scilab/sciunsignedchar.swg
new file mode 100644
index 0000000..f733895
--- /dev/null
+++ b/share/swig/3.0.12/scilab/sciunsignedchar.swg
@@ -0,0 +1,190 @@
+/*
+ * C-type: unsigned char
+ * Scilab type: double or uint8
+ */
+%fragment(SWIG_AsVal_frag(unsigned char), "header", fragment="SWIG_SciDoubleOrUint8_AsUnsignedChar", fragment="<limits.h>") {
+#define SWIG_AsVal_unsigned_SS_char(scilabValue, valuePointer) SWIG_SciDoubleOrUint8_AsUnsignedChar(pvApiCtx, scilabValue, valuePointer, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_SciDoubleOrUint8_AsUnsignedChar", "header") {
+SWIGINTERN int
+SWIG_SciDoubleOrUint8_AsUnsignedChar(void *pvApiCtx, int iVar, unsigned char *pucValue, char *fname) {
+  SciErr sciErr;
+  int iType = 0;
+  int iRows = 0;
+  int iCols = 0;
+  int iPrec = 0;
+  int *piAddrVar = NULL;
+  unsigned char *pucData = NULL;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  sciErr = getVarType(pvApiCtx, piAddrVar, &iType);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (iType == sci_ints) {
+    if (pucValue) {
+      sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddrVar, &iPrec);
+      if (sciErr.iErr) {
+        printError(&sciErr, 0);
+        return SWIG_ERROR;
+      }
+      if (iPrec != SCI_UINT8) {
+        Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 8-bit unsigned integer or a double expected.\n"), fname, iVar);
+        return SWIG_ERROR;
+      }
+
+      sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, piAddrVar, &iRows, &iCols, &pucData);
+      if (sciErr.iErr) {
+        printError(&sciErr, 0);
+        return SWIG_ERROR;
+      }
+      if (iRows * iCols != 1) {
+        Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong size for input argument #%d: A 8-bit unsigned integer or a double expected.\n"), fname, iVar);
+        return SWIG_ERROR;
+      }
+      *pucValue = *pucData;
+    }
+  }
+  else if (iType == sci_matrix) {
+    if (pucValue) {
+      double *pdData = NULL;
+      double dValue = 0.0f;
+      sciErr = getMatrixOfDouble(pvApiCtx, piAddrVar, &iRows, &iCols, &pdData);
+      if (sciErr.iErr) {
+        printError(&sciErr, 0);
+        return SWIG_ERROR;
+      }
+      if (iRows * iCols != 1) {
+        Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong size for input argument #%d: A 8-bit unsigned integer or a double expected.\n"), fname, iVar);
+        return SWIG_TypeError;
+      }
+      dValue = *pdData;
+      if (dValue != floor(dValue)) {
+        Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 8-bit unsigned integer.\n"), fname, iVar);
+        return SWIG_ValueError;
+      }
+      if ((dValue < 0) || (dValue > UCHAR_MAX)) {
+        Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 8-bit unsigned integer.\n"), fname, iVar);
+        return SWIG_OverflowError;
+      }
+      *pucValue = (unsigned char) dValue;
+    }
+  }
+  else {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 8-bit unsigned integer or a double expected.\n"), fname, iVar);
+    return SWIG_ERROR;
+  }
+
+  return SWIG_OK;
+}
+}
+
+%fragment(SWIG_From_frag(unsigned char), "header", fragment="SWIG_SciDouble_FromUnsignedChar") {
+#define SWIG_From_unsigned_SS_char(value) SWIG_SciDouble_FromUnsignedChar(pvApiCtx, SWIG_Scilab_GetOutputPosition(), value)
+}
+%fragment("SWIG_SciDouble_FromUnsignedChar", "header") {
+SWIGINTERN int
+SWIG_SciDouble_FromUnsignedChar(void *pvApiCtx, int iVarOut, unsigned char ucValue) {
+  if (createScalarDouble(pvApiCtx,
+    SWIG_NbInputArgument(pvApiCtx) + iVarOut, (double) ucValue))
+    return SWIG_ERROR;
+  return SWIG_OK;
+}
+}
+
+/*
+ * C-type: unsigned char[]
+  * Scilab type: double or uint8 matrix
+ */
+%fragment("SWIG_SciDoubleOrUint8_AsUnsignedCharArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciDoubleOrUint8_AsUnsignedCharArrayAndSize(void *pvApiCtx, int iVar, int *iRows, int *iCols, unsigned char **pucValue, char *fname) {
+  SciErr sciErr;
+  int iType = 0;
+  int iPrec = 0;
+  int *piAddrVar = NULL;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  sciErr = getVarType(pvApiCtx, piAddrVar, &iType);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (iType == sci_matrix) {
+    double *pdData = NULL;
+    int size = 0;
+    int i;
+
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrVar, iRows, iCols, &pdData);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+
+    size = (*iRows) * (*iCols);
+    *pucValue = (unsigned char*) malloc(size * sizeof(int*));
+    for (i = 0; i < size; i++)
+      (*pucValue)[i] = (unsigned char) pdData[i];
+  }
+  else if (iType == sci_ints) {
+    sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddrVar, &iPrec);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+
+    if (iPrec != SCI_UINT8) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 8-bit unsigned integer or a double vector expected.\n"), fname, iVar);
+      return SWIG_ERROR;
+    }
+
+    sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, piAddrVar, iRows, iCols, pucValue);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+  }
+  else {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 8-bit unsigned integer or a double vector expected.\n"), fname, iVar);
+    return SWIG_ERROR;
+  }
+
+  return SWIG_OK;
+}
+}
+
+%fragment("SWIG_SciDouble_FromUnsignedCharArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciDouble_FromUnsignedCharArrayAndSize(void *pvApiCtx, int iVarOut, int iRows, int iCols, const unsigned char *pucValues) {
+  SciErr sciErr;
+  double *pdValues = NULL;
+  int i;
+
+  pdValues = (double*) malloc(iRows * iCols * sizeof(double));
+  for (i=0; i<iRows * iCols; i++)
+    pdValues[i] = pucValues[i];
+
+  sciErr = createMatrixOfDouble(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, iRows, iCols, pdValues);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    free(pdValues);
+    return SWIG_ERROR;
+  }
+
+  free(pdValues);
+  return SWIG_OK;
+}
+}
diff --git a/share/swig/3.0.12/scilab/sciunsignedint.swg b/share/swig/3.0.12/scilab/sciunsignedint.swg
new file mode 100644
index 0000000..021b0ea
--- /dev/null
+++ b/share/swig/3.0.12/scilab/sciunsignedint.swg
@@ -0,0 +1,204 @@
+/*
+ * C-type: unsigned int
+ * Scilab type: double or uint32
+ */
+%fragment(SWIG_AsVal_frag(unsigned int), "header", fragment="SWIG_SciDoubleOrUint32_AsUnsignedInt", fragment="<limits.h>") {
+%#define SWIG_AsVal_unsigned_SS_int(scilabValue, valuePointer) SWIG_SciDoubleOrUint32_AsUnsignedInt(pvApiCtx, scilabValue, valuePointer, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_SciDoubleOrUint32_AsUnsignedInt", "header") {
+SWIGINTERN int
+SWIG_SciDoubleOrUint32_AsUnsignedInt(void *pvApiCtx, int iVar, unsigned int *puiValue, char *fname) {
+  SciErr sciErr;
+  int iType = 0;
+  int iRows = 0;
+  int iCols = 0;
+  int iPrec = 0;
+  int *piAddrVar = NULL;
+  unsigned int *puiData = NULL;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  sciErr = getVarType(pvApiCtx, piAddrVar, &iType);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (iType == sci_ints) {
+    if (puiValue) {
+      sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddrVar, &iPrec);
+      if (sciErr.iErr) {
+        printError(&sciErr, 0);
+        return SWIG_ERROR;
+      }
+      if (iPrec != SCI_UINT32) {
+        Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 32-bit unsigned integer or a double expected.\n"), fname, iVar);
+        return SWIG_ERROR;
+      }
+
+      sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, piAddrVar, &iRows, &iCols, &puiData);
+      if (sciErr.iErr) {
+        printError(&sciErr, 0);
+        return SWIG_ERROR;
+      }
+      if (iRows * iCols != 1) {
+        Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong size for input argument #%d: A 32-bit unsigned integer or a double expected.\n"), fname, iVar);
+        return SWIG_ERROR;
+      }
+      *puiValue = *puiData;
+    }
+  }
+  else if (iType == sci_matrix) {
+    if (puiValue) {
+      double *pdData = NULL;
+      double dValue = 0.0f;
+      sciErr = getMatrixOfDouble(pvApiCtx, piAddrVar, &iRows, &iCols, &pdData);
+      if (sciErr.iErr) {
+        printError(&sciErr, 0);
+        return SWIG_ERROR;
+      }
+      if (iRows * iCols != 1) {
+        Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong size for input argument #%d: A 32-bit unsigned integer or a double expected.\n"), fname, iVar);
+        return SWIG_TypeError;
+      }
+      dValue = *pdData;
+      if (dValue != floor(dValue)) {
+        Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 32-bit unsigned integer.\n"), fname, iVar);
+        return SWIG_ValueError;
+      }
+      if ((dValue < 0) || (dValue > UINT_MAX)) {
+        Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 32-bit unsigned integer.\n"), fname, iVar);
+        return SWIG_OverflowError;
+      }
+      *puiValue = (unsigned int) dValue;
+    }
+  }
+  else {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 32-bit unsigned integer or a double expected.\n"), fname, iVar);
+    return SWIG_ERROR;
+  }
+
+  return SWIG_OK;
+}
+}
+
+%fragment(SWIG_From_frag(unsigned int), "header", fragment="SWIG_SciDouble_FromUnsignedInt") {
+%#define SWIG_From_unsigned_SS_int(scilabValue) SWIG_SciDouble_FromUnsignedInt(pvApiCtx, SWIG_Scilab_GetOutputPosition(), scilabValue, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_SciDouble_FromUnsignedInt", "header") {
+SWIGINTERN int
+SWIG_SciDouble_FromUnsignedInt(void *pvApiCtx, int iVarOut, unsigned int uiValue, char *fname) {
+  if (createScalarDouble(pvApiCtx,
+    SWIG_NbInputArgument(pvApiCtx) + iVarOut, (double) uiValue))
+    return SWIG_ERROR;
+  return SWIG_OK;
+}
+}
+
+/*
+ * C-type: unsigned int[]
+ * Scilab type: uint32 vector
+ */
+%fragment("SWIG_SciDoubleOrUint32_AsUnsignedIntArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciDoubleOrUint32_AsUnsignedIntArrayAndSize(void *pvApiCtx, int iVar, int *iRows, int *iCols, unsigned int **puiValue, char *fname) {
+  SciErr sciErr;
+  int iType = 0;
+  int iPrec = 0;
+  int *piAddrVar = NULL;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  sciErr = getVarType(pvApiCtx, piAddrVar, &iType);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (iType == sci_matrix) {
+    double *pdData = NULL;
+    int size = 0;
+    int i;
+
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrVar, iRows, iCols, &pdData);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+
+    size = (*iRows) * (*iCols);
+    *puiValue = (unsigned int*) malloc(size * sizeof(int*));
+    for (i = 0; i < size; i++)
+      (*puiValue)[i] = (unsigned int) pdData[i];
+  }
+  else if (iType == sci_ints) {
+    sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddrVar, &iPrec);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+
+    if (iPrec != SCI_UINT32) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 32-bit unsigned integer or a double vector expected.\n"), fname, iVar);
+      return SWIG_ERROR;
+    }
+
+    sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, piAddrVar, iRows, iCols, puiValue);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+  }
+  else {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 32-bit unsigned integer or a double vector expected.\n"), fname, iVar);
+    return SWIG_ERROR;
+  }
+
+  return SWIG_OK;
+}
+}
+
+%fragment("SWIG_SciDouble_FromUnsignedIntArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciDouble_FromUnsignedIntArrayAndSize(void *pvApiCtx, int iVarOut, int iRows, int iCols, unsigned int *puiValues) {
+  SciErr sciErr;
+  double *pdValues = NULL;
+  int i;
+
+  pdValues = (double*) malloc(iRows * iCols * sizeof(double));
+  for (i=0; i<iRows * iCols; i++)
+    pdValues[i] = puiValues[i];
+
+  sciErr = createMatrixOfDouble(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, iRows, iCols, pdValues);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    free(pdValues);
+    return SWIG_ERROR;
+  }
+
+  free(pdValues);
+  return SWIG_OK;
+}
+}
+
+%fragment(SWIG_CreateScilabVariable_frag(uint), "wrapper") {
+SWIGINTERN int
+SWIG_CreateScilabVariable_dec(uint)(void *pvApiCtx, const char* psVariableName, const unsigned int uiVariableValue) {
+  SciErr sciErr;
+  sciErr = createNamedMatrixOfUnsignedInteger32(pvApiCtx, psVariableName, 1, 1, &uiVariableValue);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+  return SWIG_OK;
+}
+}
+
diff --git a/share/swig/3.0.12/scilab/sciunsignedlong.swg b/share/swig/3.0.12/scilab/sciunsignedlong.swg
new file mode 100644
index 0000000..0e9b906
--- /dev/null
+++ b/share/swig/3.0.12/scilab/sciunsignedlong.swg
@@ -0,0 +1,53 @@
+/*
+ * C-type: unsigned long
+ * Scilab type: see unsigned int
+ */
+
+%fragment(SWIG_AsVal_frag(unsigned long), "header", fragment="SWIG_UnsignedInt_AsUnsignedLong") {
+#define SWIG_AsVal_unsigned_SS_long(scilabValue, valuePointer) SWIG_UnsignedInt_AsUnsignedLong(pvApiCtx, scilabValue, valuePointer, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_UnsignedInt_AsUnsignedLong", "header", fragment=SWIG_AsVal_frag(unsigned int)) {
+SWIGINTERN int
+SWIG_UnsignedInt_AsUnsignedLong(void *pvApiCtx, SwigSciObject iVar, unsigned long *pulValue, char *fname) {
+  unsigned int uiValue = 0;
+  if(SWIG_AsVal_unsigned_SS_int(iVar, &uiValue) != SWIG_OK) {
+    return SWIG_ERROR;
+  }
+  *pulValue = (unsigned long) uiValue;
+  return SWIG_OK;
+}
+}
+
+%fragment(SWIG_From_frag(unsigned long), "header", fragment="SWIG_UnsignedInt_FromUnsignedLong") {
+#define SWIG_From_unsigned_SS_long(scilabValue) SWIG_UnsignedInt_FromUnsignedLong(pvApiCtx, SWIG_Scilab_GetOutputPosition(), scilabValue, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_UnsignedInt_FromUnsignedLong", "header", fragment=SWIG_From_frag(unsigned int)) {
+SWIGINTERN int
+SWIG_UnsignedInt_FromUnsignedLong(void *pvApiCtx, int iVarOut, unsigned long ulValue, char *fname) {
+  return SWIG_From_unsigned_SS_int((unsigned int)ulValue);
+}
+}
+
+%fragment("SWIG_SciDouble_FromUnsignedLongArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciDouble_FromUnsignedLongArrayAndSize(void *pvApiCtx, int iVarOut, int iRows, int iCols, const unsigned long *pulValues) {
+  SciErr sciErr;
+  double *pdValues = NULL;
+  int i;
+
+  pdValues = (double*) malloc(iRows * iCols * sizeof(double));
+  for (i=0; i<iRows * iCols; i++) {
+    pdValues[i] = pulValues[i];
+  }
+
+  sciErr = createMatrixOfDouble(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, iRows, iCols, pdValues);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    free(pdValues);
+    return SWIG_ERROR;
+  }
+
+  free(pdValues);
+  return SWIG_OK;
+}
+}
diff --git a/share/swig/3.0.12/scilab/sciunsignedshort.swg b/share/swig/3.0.12/scilab/sciunsignedshort.swg
new file mode 100644
index 0000000..110fba4
--- /dev/null
+++ b/share/swig/3.0.12/scilab/sciunsignedshort.swg
@@ -0,0 +1,189 @@
+/*
+ * C-type: unsigned short
+ * Scilab type: double or uint16
+ */
+%fragment(SWIG_AsVal_frag(unsigned short), "header", fragment="SWIG_SciDoubleOrUint16_AsUnsignedShort", fragment="<limits.h>") {
+%#define SWIG_AsVal_unsigned_SS_short(scilabValue, valuePointer) SWIG_SciDoubleOrUint16_AsUnsignedShort(pvApiCtx, scilabValue, valuePointer, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_SciDoubleOrUint16_AsUnsignedShort", "header") {
+SWIGINTERN int
+SWIG_SciDoubleOrUint16_AsUnsignedShort(void *pvApiCtx, int iVar, unsigned short *pusValue, char *fname) {
+  SciErr sciErr;
+  int iType = 0;
+  int iRows = 0;
+  int iCols = 0;
+  int iPrec = 0;
+  int *piAddrVar = NULL;
+  unsigned short *pusData = NULL;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  sciErr = getVarType(pvApiCtx, piAddrVar, &iType);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (iType == sci_ints) {
+    if (pusValue) {
+      sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddrVar, &iPrec);
+      if (sciErr.iErr) {
+        printError(&sciErr, 0);
+        return SWIG_ERROR;
+      }
+      if (iPrec != SCI_UINT16) {
+        Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 16-bit unsigned integer or a double expected.\n"), fname, iVar);
+        return SWIG_ERROR;
+      }
+
+      sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, piAddrVar, &iRows, &iCols, &pusData);
+      if (sciErr.iErr) {
+        printError(&sciErr, 0);
+        return SWIG_ERROR;
+      }
+      if (iRows * iCols != 1) {
+        Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong size for input argument #%d: A 16-bit unsigned integer or a double expected.\n"), fname, iVar);
+        return SWIG_ERROR;
+      }
+      *pusValue = *pusData;
+    }
+  }
+  else if (iType == sci_matrix) {
+    if (pusValue) {
+      double *pdData = NULL;
+      double dValue = 0.0f;
+      sciErr = getMatrixOfDouble(pvApiCtx, piAddrVar, &iRows, &iCols, &pdData);
+      if (sciErr.iErr) {
+        printError(&sciErr, 0);
+        return SWIG_ERROR;
+      }
+      if (iRows * iCols != 1) {
+        Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong size for input argument #%d: A 16-bit unsigned integer or a double expected.\n"), fname, iVar);
+        return SWIG_TypeError;
+      }
+      dValue = *pdData;
+      if (dValue != floor(dValue)) {
+        Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 16-bit unsigned integer.\n"), fname, iVar);
+        return SWIG_ValueError;
+      }
+      if ((dValue < 0) || (dValue > USHRT_MAX)) {
+        Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 16-bit unsigned integer.\n"), fname, iVar);
+        return SWIG_OverflowError;
+      }
+      *pusValue = (unsigned short) dValue;
+    }
+  }
+  else {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 16-bit unsigned integer or a double expected.\n"), fname, iVar);
+    return SWIG_ERROR;
+  }
+
+  return SWIG_OK;
+}
+}
+
+%fragment(SWIG_From_frag(unsigned short), "header", fragment="SWIG_SciDouble_FromUnsignedShort") {
+%#define SWIG_From_unsigned_SS_short(scilabValue) SWIG_SciDouble_FromUnsignedShort(pvApiCtx, SWIG_Scilab_GetOutputPosition(), scilabValue, SWIG_Scilab_GetFuncName())
+}
+%fragment("SWIG_SciDouble_FromUnsignedShort", "header") {
+SWIGINTERN int
+SWIG_SciDouble_FromUnsignedShort(void *pvApiCtx, int iVarOut, unsigned short usValue, char *fname) {
+  if (createScalarDouble(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, (double) usValue))
+    return SWIG_ERROR;
+  return SWIG_OK;
+}
+}
+
+/*
+ * C-type: unsigned short[]
+ * Scilab type: uint16 vector
+ */
+%fragment("SWIG_SciDoubleOrUint16_AsUnsignedShortArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciDoubleOrUint16_AsUnsignedShortArrayAndSize(void *pvApiCtx, int iVar, int *iRows, int *iCols, unsigned short **pusValue, char *fname) {
+  SciErr sciErr;
+  int iType = 0;
+  int iPrec = 0;
+  int *piAddrVar = NULL;
+
+  sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  sciErr = getVarType(pvApiCtx, piAddrVar, &iType);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    return SWIG_ERROR;
+  }
+
+  if (iType == sci_matrix) {
+    double *pdData = NULL;
+    int size = 0;
+    int i;
+
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrVar, iRows, iCols, &pdData);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+
+    size = (*iRows) * (*iCols);
+    *pusValue = (unsigned short*) malloc(size * sizeof(int*));
+    for (i = 0; i < size; i++)
+      (*pusValue)[i] = (unsigned short) pdData[i];
+  }
+  else if (iType == sci_ints) {
+    sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddrVar, &iPrec);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+
+    if (iPrec != SCI_UINT16) {
+      Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 16-bit unsigned integer or a double vector expected.\n"), fname, iVar);
+      return SWIG_ERROR;
+    }
+
+    sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, piAddrVar, iRows, iCols, pusValue);
+    if (sciErr.iErr) {
+      printError(&sciErr, 0);
+      return SWIG_ERROR;
+    }
+  }
+  else {
+    Scierror(SCILAB_API_ARGUMENT_ERROR, _("%s: Wrong type for input argument #%d: A 16-bit unsigned integer or a double vector expected.\n"), fname, iVar);
+    return SWIG_ERROR;
+  }
+
+  return SWIG_OK;
+}
+}
+
+%fragment("SWIG_SciDouble_FromUnsignedShortArrayAndSize", "header") {
+SWIGINTERN int
+SWIG_SciDouble_FromUnsignedShortArrayAndSize(void *pvApiCtx, int iVarOut, int iRows, int iCols, unsigned short *pusValues) {
+  SciErr sciErr;
+  double *pdValues = NULL;
+  int i;
+
+  pdValues = (double*) malloc(iRows * iCols * sizeof(double));
+  for (i=0; i<iRows * iCols; i++)
+    pdValues[i] = pusValues[i];
+
+  sciErr = createMatrixOfDouble(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, iRows, iCols, pdValues);
+  if (sciErr.iErr) {
+    printError(&sciErr, 0);
+    free(pdValues);
+    return SWIG_ERROR;
+  }
+
+  free(pdValues);
+  return SWIG_OK;
+}
+}
diff --git a/share/swig/3.0.12/scilab/std_alloc.i b/share/swig/3.0.12/scilab/std_alloc.i
new file mode 100644
index 0000000..6ea03aa
--- /dev/null
+++ b/share/swig/3.0.12/scilab/std_alloc.i
@@ -0,0 +1,2 @@
+%include <std/std_alloc.i>
+
diff --git a/share/swig/3.0.12/scilab/std_basic_string.i b/share/swig/3.0.12/scilab/std_basic_string.i
new file mode 100644
index 0000000..43b660d
--- /dev/null
+++ b/share/swig/3.0.12/scilab/std_basic_string.i
@@ -0,0 +1,46 @@
+/*
+ * C++: basic_string<char>
+ * Scilab: string
+ */
+
+#define %swig_basic_string(Type...)  %swig_sequence_methods_val(Type)
+
+%fragment(SWIG_AsPtr_frag(std::basic_string<char>), "header", fragment="SWIG_SciString_AsCharPtrAndLength") {
+SWIGINTERN int
+SWIG_AsPtr_dec(std::basic_string<char>)(int _iVar, std::basic_string<char> **_pstValue) {
+  char* buf = 0;
+  size_t len = 0;
+  int alloc = SWIG_OLDOBJ;
+
+  if (SWIG_IsOK((SWIG_SciString_AsCharPtrAndSize(pvApiCtx, _iVar, &buf, &len, &alloc, SWIG_Scilab_GetFuncName())))) {
+    if (buf) {
+      if (_pstValue) {
+        *_pstValue = new std::string(buf, len - 1);
+      }
+      if (alloc == SWIG_NEWOBJ) {
+        delete[] buf;
+      }
+      return SWIG_NEWOBJ;
+    }
+    else {
+      if (_pstValue) {
+        *_pstValue = NULL;
+      }
+      return SWIG_OLDOBJ;
+    }
+  } else {
+    return SWIG_ERROR;
+  }
+}
+}
+
+%fragment(SWIG_From_frag(std::basic_string<char>), "header", fragment="SWIG_SciString_FromCharPtr") {
+SWIGINTERN int
+SWIG_From_dec(std::basic_string<char>)(std::basic_string<char> _pstValue) {
+    return SWIG_SciString_FromCharPtr(pvApiCtx, SWIG_Scilab_GetOutputPosition(), _pstValue.c_str());
+}
+}
+
+%include <std/std_basic_string.i>
+
+
diff --git a/share/swig/3.0.12/scilab/std_char_traits.i b/share/swig/3.0.12/scilab/std_char_traits.i
new file mode 100644
index 0000000..bf4e6c4
--- /dev/null
+++ b/share/swig/3.0.12/scilab/std_char_traits.i
@@ -0,0 +1 @@
+%include <std/std_char_traits.i>
diff --git a/share/swig/3.0.12/scilab/std_common.i b/share/swig/3.0.12/scilab/std_common.i
new file mode 100644
index 0000000..97cfa7b
--- /dev/null
+++ b/share/swig/3.0.12/scilab/std_common.i
@@ -0,0 +1,72 @@
+%include <std/std_except.i>
+%include <scistdcommon.swg>
+
+
+// Generate the traits for a 'primitive' type, such as 'double',
+// for which the SWIG_AsVal and SWIG_From methods are already defined.
+
+%define %traits_ptypen(Type...)
+  %fragment(SWIG_Traits_frag(Type),"header",
+	    fragment=SWIG_AsVal_frag(Type),
+	    fragment=SWIG_From_frag(Type),
+	    fragment="StdTraits") {
+namespace swig {
+  template <> struct traits< Type > {
+    typedef value_category category;
+    static const char* type_name() { return  #Type; }
+  };
+  template <>  struct traits_asval< Type > {
+    typedef Type value_type;
+    static int asval(SwigSciObject obj, value_type *val) {
+      return SWIG_AsVal(Type)(obj, val);
+    }
+  };
+  template <>  struct traits_from< Type > {
+    typedef Type value_type;
+    static SwigSciObject from(const value_type& val) {
+      return SWIG_From(Type)(val);
+    }
+  };
+}
+}
+%enddef
+
+/* Traits for enums. This is bit of a sneaky trick needed because a generic template specialization of enums
+   is not possible (unless using template meta-programming which SWIG doesn't support because of the explicit
+   instantiations required using %template). The STL containers define the 'front' method and the typemap
+   below is used whenever the front method is wrapped returning an enum. This typemap simply picks up the
+   standard enum typemap, but additionally drags in a fragment containing the traits_asval and traits_from
+   required in the generated code for enums. */
+
+%define %traits_enum(Type...)
+  %fragment("SWIG_Traits_enum_"{Type},"header",
+	    fragment=SWIG_AsVal_frag(int),
+	    fragment=SWIG_From_frag(int),
+	    fragment="StdTraits") {
+namespace swig {
+  template <>  struct traits_asval< Type > {
+    typedef Type value_type;
+    static int asval(SwigSciObject obj, value_type *val) {
+      return SWIG_AsVal(int)(obj, (int *)val);
+    }
+  };
+  template <>  struct traits_from< Type > {
+    typedef Type value_type;
+    static SwigSciObject from(const value_type& val) {
+      return SWIG_From(int)((int)val);
+    }
+  };
+}
+}
+%typemap(out, fragment="SWIG_Traits_enum_"{Type}) const enum SWIGTYPE& front %{$typemap(out, const enum SWIGTYPE&)%}
+%enddef
+
+
+%include <std/std_common.i>
+
+//
+// Generates the traits for all the known primitive
+// C++ types (int, double, ...)
+//
+%apply_cpptypes(%traits_ptypen);
+
diff --git a/share/swig/3.0.12/scilab/std_container.i b/share/swig/3.0.12/scilab/std_container.i
new file mode 100644
index 0000000..a1e037b
--- /dev/null
+++ b/share/swig/3.0.12/scilab/std_container.i
@@ -0,0 +1,3 @@
+%include <scicontainer.swg>
+%include <std/std_container.i>
+
diff --git a/share/swig/3.0.12/scilab/std_deque.i b/share/swig/3.0.12/scilab/std_deque.i
new file mode 100644
index 0000000..d2ca597
--- /dev/null
+++ b/share/swig/3.0.12/scilab/std_deque.i
@@ -0,0 +1,31 @@
+/*
+ *
+ * C++ type : STL deque
+ * Scilab type : matrix (for primitive types) or list (for pointer types)
+ *
+*/
+
+%fragment("StdDequeTraits", "header", fragment="StdSequenceTraits")
+%{
+  namespace swig {
+    template <class T>
+    struct traits_asptr<std::deque<T> >  {
+      static int asptr(const SwigSciObject &obj, std::deque<T> **deq) {
+        return traits_asptr_stdseq<std::deque<T> >::asptr(obj, deq);
+      }
+    };
+
+    template <class T>
+    struct traits_from<std::deque<T> > {
+      static SwigSciObject from(const std::deque<T>& deq) {
+	      return traits_from_stdseq<std::deque<T> >::from(deq);
+      }
+    };
+  }
+%}
+
+
+#define %swig_deque_methods(Type...) %swig_sequence_methods(Type)
+#define %swig_deque_methods_val(Type...) %swig_sequence_methods_val(Type);
+
+%include <std/std_deque.i>
diff --git a/share/swig/3.0.12/scilab/std_except.i b/share/swig/3.0.12/scilab/std_except.i
new file mode 100644
index 0000000..af98428
--- /dev/null
+++ b/share/swig/3.0.12/scilab/std_except.i
@@ -0,0 +1 @@
+%include <typemaps/std_except.swg>
diff --git a/share/swig/3.0.12/scilab/std_list.i b/share/swig/3.0.12/scilab/std_list.i
new file mode 100644
index 0000000..75d002d
--- /dev/null
+++ b/share/swig/3.0.12/scilab/std_list.i
@@ -0,0 +1,30 @@
+/*
+ *
+ * C++ type : STL list
+ * Scilab type : matrix (for primitive types) or list (for pointer types)
+ *
+*/
+
+%fragment("StdListTraits", "header", fragment="StdSequenceTraits")
+%{
+  namespace swig {
+    template <class T >
+    struct traits_asptr<std::list<T> >  {
+      static int asptr(SwigSciObject obj, std::list<T> **lis) {
+	      return traits_asptr_stdseq<std::list<T> >::asptr(obj, lis);
+      }
+    };
+
+    template <class T>
+    struct traits_from<std::list<T> > {
+      static SwigSciObject from(const std::list<T> &lis) {
+	      return traits_from_stdseq<std::list<T> >::from(lis);
+      }
+    };
+  }
+%}
+
+#define %swig_list_methods(Type...) %swig_sequence_methods(Type)
+#define %swig_list_methods_val(Type...) %swig_sequence_methods_val(Type);
+
+%include <std/std_list.i>
diff --git a/share/swig/3.0.12/scilab/std_map.i b/share/swig/3.0.12/scilab/std_map.i
new file mode 100644
index 0000000..250d2d8
--- /dev/null
+++ b/share/swig/3.0.12/scilab/std_map.i
@@ -0,0 +1,69 @@
+//
+// SWIG typemaps for std::map
+//
+// Common implementation
+
+%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:
+        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();
+            }
+        }
+    };
+
+// 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/3.0.12/scilab/std_multiset.i b/share/swig/3.0.12/scilab/std_multiset.i
new file mode 100644
index 0000000..67e1792
--- /dev/null
+++ b/share/swig/3.0.12/scilab/std_multiset.i
@@ -0,0 +1,30 @@
+/*
+ *
+ * C++ type : STL multiset
+ * Scilab type : matrix (for primitive types) or list (for pointer types)
+ *
+*/
+
+%fragment("StdMultisetTraits", "header", fragment="StdSequenceTraits")
+%{
+  namespace swig {
+    template <class T>
+    struct traits_asptr<std::multiset<T> >  {
+      static int asptr(const SwigSciObject &obj, std::multiset<T> **multiset) {
+        return traits_asptr_stdseq<std::multiset<T> >::asptr(obj, multiset);
+      }
+    };
+
+    template <class T>
+    struct traits_from<std::multiset<T> > {
+      static SwigSciObject from(const std::multiset<T>& multiset) {
+        return traits_from_stdseq<std::multiset<T> >::from(multiset);
+      }
+    };
+  }
+%}
+
+#define %swig_multiset_methods(Set...) %swig_sequence_methods(Type)
+#define %swig_multiset_methods_val(Type...) %swig_sequence_methods_val(Type);
+
+%include <std/std_multiset.i>
diff --git a/share/swig/2.0.11/tcl/std_pair.i b/share/swig/3.0.12/scilab/std_pair.i
index 1448d65..1448d65 100644
--- a/share/swig/2.0.11/tcl/std_pair.i
+++ b/share/swig/3.0.12/scilab/std_pair.i
diff --git a/share/swig/3.0.12/scilab/std_set.i b/share/swig/3.0.12/scilab/std_set.i
new file mode 100644
index 0000000..9070e2d
--- /dev/null
+++ b/share/swig/3.0.12/scilab/std_set.i
@@ -0,0 +1,32 @@
+/*
+ *
+ * C++ type : STL set
+ * Scilab type : matrix (for primitive types) or list (for pointer types)
+ *
+*/
+
+%fragment("StdSetTraits", "header", fragment="StdSequenceTraits")
+%{
+  namespace swig {
+    template <class T>
+    struct traits_asptr<std::set<T> >  {
+      static int asptr(const SwigSciObject &obj, std::set<T> **set) {
+        return traits_asptr_stdseq<std::set<T> >::asptr(obj, set);
+      }
+    };
+
+    template <class T>
+    struct traits_from<std::set<T> > {
+      static SwigSciObject from(const std::set<T>& set) {
+        return traits_from_stdseq<std::set<T> >::from(set);
+      }
+    };
+  }
+%}
+
+
+#define %swig_set_methods(Type...) %swig_sequence_methods(Type)
+#define %swig_set_methods_val(Type...) %swig_sequence_methods_val(Type);
+
+%include <std/std_set.i>
+
diff --git a/share/swig/3.0.12/scilab/std_string.i b/share/swig/3.0.12/scilab/std_string.i
new file mode 100644
index 0000000..71ac6d2
--- /dev/null
+++ b/share/swig/3.0.12/scilab/std_string.i
@@ -0,0 +1,39 @@
+/*
+ * POINTER
+ */
+%fragment(SWIG_AsPtr_frag(std::string), "header", fragment="SWIG_SciString_AsCharPtrAndSize") {
+SWIGINTERN int
+SWIG_AsPtr_dec(std::string)(int iVar, std::string **pstValue) {
+  char* buf = 0;
+  size_t size = 0;
+  int alloc = SWIG_OLDOBJ;
+
+  if (SWIG_IsOK((SWIG_SciString_AsCharPtrAndSize(pvApiCtx, iVar, &buf, &size, &alloc, SWIG_Scilab_GetFuncName())))) {
+    if (buf) {
+      if (pstValue) {
+        *pstValue = new std::string(buf, size);
+      }
+      if (alloc == SWIG_NEWOBJ) {
+        delete[] buf;
+      }
+      return SWIG_NEWOBJ;
+    } else {
+      if (pstValue) {
+        *pstValue = NULL;
+      }
+      return SWIG_OLDOBJ;
+    }
+  } else {
+    return SWIG_ERROR;
+  }
+}
+}
+
+%fragment(SWIG_From_frag(std::string), "header", fragment="SWIG_SciString_FromCharPtr") {
+SWIGINTERN int
+SWIG_From_dec(std::string)(std::string pstValue) {
+    return SWIG_SciString_FromCharPtr(pvApiCtx, SWIG_Scilab_GetOutputPosition(), pstValue.c_str());
+}
+}
+
+%include <typemaps/std_string.swg>
diff --git a/share/swig/3.0.12/scilab/std_vector.i b/share/swig/3.0.12/scilab/std_vector.i
new file mode 100644
index 0000000..6eaeeca
--- /dev/null
+++ b/share/swig/3.0.12/scilab/std_vector.i
@@ -0,0 +1,31 @@
+/*
+ *
+ * C++ type : STL vector
+ * Scilab type : matrix (for primitive types) or list (for pointer types)
+ *
+*/
+
+%fragment("StdVectorTraits", "header", fragment="StdSequenceTraits")
+%{
+  namespace swig {
+    template <class T>
+    struct traits_asptr<std::vector<T> >  {
+      static int asptr(const SwigSciObject &obj, std::vector<T> **vec) {
+        return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
+      }
+    };
+
+    template <class T>
+    struct traits_from<std::vector<T> > {
+      static SwigSciObject from(const std::vector<T>& vec) {
+	      return traits_from_stdseq<std::vector<T> >::from(vec);
+      }
+    };
+  }
+%}
+
+
+#define %swig_vector_methods(Type...) %swig_sequence_methods(Type)
+#define %swig_vector_methods_val(Type...) %swig_sequence_methods_val(Type);
+
+%include <std/std_vector.i>
diff --git a/share/swig/3.0.12/scilab/stl.i b/share/swig/3.0.12/scilab/stl.i
new file mode 100644
index 0000000..b29f7d8
--- /dev/null
+++ b/share/swig/3.0.12/scilab/stl.i
@@ -0,0 +1,6 @@
+/* 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/3.0.12/scilab/typemaps.i b/share/swig/3.0.12/scilab/typemaps.i
new file mode 100644
index 0000000..9d71387
--- /dev/null
+++ b/share/swig/3.0.12/scilab/typemaps.i
@@ -0,0 +1,62 @@
+/* -----------------------------------------------------------------------------
+ * typemaps.i
+ *
+ * ----------------------------------------------------------------------------- */
+
+// INPUT typemaps
+%define %scilab_input_typemap(Type)
+%typemap(in, noblock=1, fragment=SWIG_AsVal_frag(Type)) Type *INPUT(Type temp)(int ecode), Type &INPUT(Type temp)(int ecode) {
+  ecode = SWIG_AsVal_dec(Type)($input, &temp);
+  if (!SWIG_IsOK(ecode)) {
+    %argument_fail(ecode, "$type", $symname, $argnum);
+  }
+  $1 = &temp;
+}
+
+%typemap(freearg, noblock=1) Type *INPUT, Type &INPUT {
+}
+
+%typemap(typecheck) Type *INPUT, Type &INPUT {
+}
+%enddef
+
+// OUTPUT typemaps
+%define %scilab_output_typemap(Type)
+%typemap(argout, noblock=1, fragment=SWIG_From_frag(Type)) Type *OUTPUT, Type &OUTPUT {
+  %set_output(SWIG_From_dec(Type)(*$1));
+}
+%enddef
+
+// INOUT typemaps
+%define %scilab_inout_typemap(Type)
+ %typemap(in) Type *INOUT = Type *INPUT;
+ %typemap(in) Type &INOUT = Type &INPUT;
+ %typemap(argout) Type *INOUT = Type *OUTPUT;
+ %typemap(argout) Type &INOUT = Type &OUTPUT;
+%enddef
+
+
+%define %scilab_inout_typemaps(Type)
+  %scilab_input_typemap(%arg(Type))
+  %scilab_output_typemap(%arg(Type))
+  %scilab_inout_typemap(%arg(Type))
+%enddef
+
+%scilab_inout_typemaps(double);
+%scilab_inout_typemaps(signed char);
+%scilab_inout_typemaps(unsigned char);
+%scilab_inout_typemaps(short);
+%scilab_inout_typemaps(unsigned short);
+%scilab_inout_typemaps(int);
+%scilab_inout_typemaps(unsigned int);
+%scilab_inout_typemaps(long);
+%scilab_inout_typemaps(unsigned long);
+%scilab_inout_typemaps(bool);
+%scilab_inout_typemaps(float);
+
+//%apply_ctypes(%scilab_inout_typemaps);
+
+
+
+
+
diff --git a/share/swig/3.0.12/shared_ptr.i b/share/swig/3.0.12/shared_ptr.i
new file mode 100644
index 0000000..2975b06
--- /dev/null
+++ b/share/swig/3.0.12/shared_ptr.i
@@ -0,0 +1,71 @@
+// This is a helper file for shared_ptr and should not be included directly.
+
+// The main implementation detail in using this smart pointer of a type is to customise the code generated
+// to use a pointer to the smart pointer of the type, rather than the usual pointer to the underlying type.
+// So for some type T, shared_ptr<T> * is used rather than T *.
+
+// Another key part of the implementation is the smartptr feature:
+//   %feature("smartptr") T { shared_ptr<T> }
+// This feature marks the class T as having a smartptr to it (the shared_ptr<T> type). This is then used to
+// support smart pointers and inheritance. Say class D derives from base B, then shared_ptr<D> is marked
+// with a fake inheritance from shared_ptr<B> in the type system if the "smartptr" feature is used on both
+// B and D. This is to emulate the conversion of shared_ptr<D> to shared_ptr<B> in the target language.
+
+// shared_ptr namespaces could be boost or std or std::tr1
+// For example for std::tr1, use:
+// #define SWIG_SHARED_PTR_NAMESPACE std
+// #define SWIG_SHARED_PTR_SUBNAMESPACE tr1
+
+#if !defined(SWIG_SHARED_PTR_NAMESPACE)
+# define SWIG_SHARED_PTR_NAMESPACE boost
+#endif
+
+#if defined(SWIG_SHARED_PTR_SUBNAMESPACE)
+# define SWIG_SHARED_PTR_QNAMESPACE SWIG_SHARED_PTR_NAMESPACE::SWIG_SHARED_PTR_SUBNAMESPACE
+#else
+# define SWIG_SHARED_PTR_QNAMESPACE SWIG_SHARED_PTR_NAMESPACE
+#endif
+
+namespace SWIG_SHARED_PTR_NAMESPACE {
+#if defined(SWIG_SHARED_PTR_SUBNAMESPACE)
+  namespace SWIG_SHARED_PTR_SUBNAMESPACE {
+#endif
+    template <class T> class shared_ptr {
+    };
+#if defined(SWIG_SHARED_PTR_SUBNAMESPACE)
+  }
+#endif
+}
+
+%fragment("SWIG_null_deleter", "header") {
+struct SWIG_null_deleter {
+  void operator() (void const *) const {
+  }
+};
+%#define SWIG_NO_NULL_DELETER_0 , SWIG_null_deleter()
+%#define SWIG_NO_NULL_DELETER_1
+%#define SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW
+%#define SWIG_NO_NULL_DELETER_SWIG_POINTER_OWN
+}
+
+
+// Workaround empty first macro argument bug
+#define SWIGEMPTYHACK
+// Main user macro for defining shared_ptr typemaps for both const and non-const pointer types
+%define %shared_ptr(TYPE...)
+%feature("smartptr", noblock=1) TYPE { SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > }
+SWIG_SHARED_PTR_TYPEMAPS(SWIGEMPTYHACK, TYPE)
+SWIG_SHARED_PTR_TYPEMAPS(const, TYPE)
+%enddef
+
+// Legacy macros
+%define SWIG_SHARED_PTR(PROXYCLASS, TYPE...)
+#warning "SWIG_SHARED_PTR(PROXYCLASS, TYPE) is deprecated. Please use %shared_ptr(TYPE) instead."
+%shared_ptr(TYPE)
+%enddef
+
+%define SWIG_SHARED_PTR_DERIVED(PROXYCLASS, BASECLASSTYPE, TYPE...)
+#warning "SWIG_SHARED_PTR_DERIVED(PROXYCLASS, BASECLASSTYPE, TYPE) is deprecated. Please use %shared_ptr(TYPE) instead."
+%shared_ptr(TYPE)
+%enddef
+
diff --git a/share/swig/3.0.12/std/_std_deque.i b/share/swig/3.0.12/std/_std_deque.i
new file mode 100644
index 0000000..af9db27
--- /dev/null
+++ b/share/swig/3.0.12/std/_std_deque.i
@@ -0,0 +1,139 @@
+/* -----------------------------------------------------------------------------
+ * _std_deque.i
+ *
+ * This file contains a generic definition of std::deque along with
+ * some helper functions.  Specific language modules should include
+ * this file to generate wrappers. 
+ * ----------------------------------------------------------------------------- */
+
+%include <std_except.i>
+
+%{
+#include <deque>
+#include <stdexcept>
+%}
+
+
+/* This macro defines all of the standard methods for a deque.  This
+   is defined as a macro to simplify the task of specialization.  For
+   example,
+
+         template<> class deque<int> {
+         public:
+             %std_deque_methods(int);
+         };
+*/
+
+%define %std_deque_methods_noempty(T...)
+       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;
+
+       deque();
+       deque(unsigned int size, const T& value=T());
+       deque(const deque< T > &);
+      ~deque();
+
+       void assign(unsigned int n, const T& value);
+       void swap(deque< T > &x);
+       unsigned int size() const;
+       unsigned int max_size() const;
+       void resize(unsigned int n, T c = T());
+       const_reference front();
+       const_reference back();
+       void push_front(const T& x);
+       void push_back(const T& x);
+       void pop_front();
+       void pop_back();
+       void clear();
+
+       /* Some useful extensions */
+       %extend {
+           const_reference getitem(int i) throw (std::out_of_range) {
+                int size = int(self->size());
+                if (i<0) i += size;
+                if (i>=0 && i<size)
+                    return (*self)[i];
+                else
+                    throw std::out_of_range("deque index out of range");
+           }
+           void setitem(int i, const T& x) throw (std::out_of_range) {
+                int size = int(self->size());
+                if (i<0) i+= size;
+                if (i>=0 && i<size)
+                    (*self)[i] = x;
+                else
+                    throw std::out_of_range("deque index out of range");
+           }
+           void delitem(int i) throw (std::out_of_range) {
+                int size = int(self->size());
+                if (i<0) i+= size;
+                if (i>=0 && i<size) {
+                    self->erase(self->begin()+i);
+                } else {
+                    throw std::out_of_range("deque index out of range");
+                }
+           }
+           std::deque< T > getslice(int i, int j) {
+                int size = int(self->size());
+                if (i<0) i = size+i;
+                if (j<0) j = size+j;
+                if (i<0) i = 0;
+                if (j>size) j = size;
+                std::deque< T > tmp(j-i);
+                std::copy(self->begin()+i,self->begin()+j,tmp.begin());
+                return tmp;
+            }
+            void setslice(int i, int j, const std::deque< T >& v) {
+                int size = int(self->size());
+                if (i<0) i = size+i;
+                if (j<0) j = size+j;
+                if (i<0) i = 0;
+                if (j>size) j = size;
+                if (int(v.size()) == j-i) {
+                    std::copy(v.begin(),v.end(),self->begin()+i);
+                } else {
+                    self->erase(self->begin()+i,self->begin()+j);
+                    if (i+1 <= size)
+                        self->insert(self->begin()+i+1,v.begin(),v.end());
+                    else
+                        self->insert(self->end(),v.begin(),v.end());
+                }
+            }
+            void delslice(int i, int j) {
+                int size = int(self->size());
+                if (i<0) i = size+i;
+                if (j<0) j = size+j;
+                if (i<0) i = 0;
+                if (j>size) j = size;
+                self->erase(self->begin()+i,self->begin()+j);
+            }
+       };
+%enddef
+
+#ifdef SWIGPHP
+%define %std_deque_methods(T...)
+    %extend {
+        bool is_empty() const {
+            return self->empty();
+        }
+    };
+    %std_deque_methods_noempty(T)
+%enddef
+#else
+%define %std_deque_methods(T...)
+    bool empty() const;
+    %std_deque_methods_noempty(T)
+%enddef
+#endif
+
+namespace std {
+    template<class T> class deque {
+    public:
+       %std_deque_methods(T);
+    };
+}
diff --git a/share/swig/2.0.11/std/std_alloc.i b/share/swig/3.0.12/std/std_alloc.i
index 44dc8dc..44dc8dc 100644
--- a/share/swig/2.0.11/std/std_alloc.i
+++ b/share/swig/3.0.12/std/std_alloc.i
diff --git a/share/swig/3.0.12/std/std_array.i b/share/swig/3.0.12/std/std_array.i
new file mode 100644
index 0000000..aadc3b8
--- /dev/null
+++ b/share/swig/3.0.12/std/std_array.i
@@ -0,0 +1,85 @@
+//
+// std::array
+//
+
+%include <std_container.i>
+
+%define %std_array_methods(array...)
+  %std_sequence_methods_non_resizable(array)
+  void fill(const value_type& u);
+%enddef
+
+
+%define %std_array_methods_val(array...)
+  %std_sequence_methods_non_resizable_val(array)
+  void fill(const value_type& u);
+%enddef
+
+// ------------------------------------------------------------------------
+// std::array
+// 
+// The aim of all that follows would be to integrate std::array with 
+// as much as possible, namely, to allow the user to pass and 
+// be returned tuples or lists.
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+// 
+//   -- f(std::array<T, N>), f(const std::array<T, N>&):
+//      the parameter being read-only, either a sequence or a
+//      previously wrapped std::array<T, N> can be passed.
+//   -- f(std::array<T, N>&), f(std::array<T, N>*):
+//      the parameter may be modified; therefore, only a wrapped std::array
+//      can be passed.
+//   -- std::array<T, N> f(), const std::array<T, N>& f():
+//      the array is returned by copy; therefore, a sequence of T:s 
+//      is returned which is most easily used in other functions
+//   -- std::array<T, N>& f(), std::array<T, N>* f():
+//      the array is returned by reference; therefore, a wrapped std::array
+//      is returned
+//   -- const std::array<T, N>* f(), f(const std::array<T, N>*):
+//      for consistency, they expect and return a plain array pointer.
+// ------------------------------------------------------------------------
+
+
+// exported classes
+
+namespace std {
+
+  template<class _Tp, size_t _Nm >
+  class array {
+  public:
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef _Tp value_type;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef _Tp& reference;
+    typedef const _Tp& const_reference;
+
+    %traits_swigtype(_Tp);
+    %traits_enum(_Tp);
+
+    %fragment(SWIG_Traits_frag(std::array< _Tp, _Nm >), "header",
+	      fragment=SWIG_Traits_frag(_Tp),
+	      fragment="StdArrayTraits") {
+      namespace swig {
+	template <>  struct traits<std::array< _Tp, _Nm > > {
+	  typedef pointer_category category;
+	  static const char* type_name() {
+	    return "std::array<" #_Tp "," #_Nm " >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_STDARRAY, std::array< _Tp, _Nm >);
+
+#ifdef %swig_array_methods
+    // Add swig/language extra methods
+    %swig_array_methods(std::array< _Tp, _Nm >);
+#endif
+
+    %std_array_methods(array);
+  };
+}
+
diff --git a/share/swig/3.0.12/std/std_basic_string.i b/share/swig/3.0.12/std/std_basic_string.i
new file mode 100644
index 0000000..fb7afc1
--- /dev/null
+++ b/share/swig/3.0.12/std/std_basic_string.i
@@ -0,0 +1,267 @@
+%include <exception.i>
+%include <std_container.i>
+%include <std_alloc.i>
+%include <std_char_traits.i>
+
+%fragment("<string>");
+
+namespace std
+{
+  %naturalvar basic_string;
+}
+
+
+namespace std {
+
+  template <class _CharT, class _Traits = char_traits<_CharT>, typename _Alloc = allocator<_CharT> > 
+  class basic_string
+  {
+#if !defined(SWIG_STD_MODERN_STL) || defined(SWIG_STD_NOMODERN_STL)
+    %ignore push_back;
+    %ignore clear;
+    %ignore compare;
+    %ignore append;
+#endif
+
+  public:
+    typedef size_t size_type;    
+    typedef ptrdiff_t difference_type;
+    typedef _CharT value_type;
+    typedef value_type reference;
+    typedef value_type const_reference;
+    typedef _Alloc allocator_type;
+    
+    static const size_type npos;
+
+#ifdef SWIG_EXPORT_ITERATOR_METHODS
+  class iterator;
+  class reverse_iterator;
+  class const_iterator;
+  class const_reverse_iterator;
+#endif
+
+
+    %traits_swigtype(_CharT);
+    %fragment(SWIG_Traits_frag(_CharT));
+    
+
+    basic_string(const _CharT* __s, size_type __n);
+
+    // Capacity:
+
+    size_type length() const;
+
+    size_type max_size() const;
+
+    size_type capacity() const;
+
+    void reserve(size_type __res_arg = 0);
+
+
+    // Modifiers:
+
+    basic_string& 
+    append(const basic_string& __str);
+
+    basic_string& 
+    append(const basic_string& __str, size_type __pos, size_type __n);
+
+    basic_string& 
+    append(const _CharT* __s, size_type __n);
+    
+    basic_string& 
+    append(size_type __n, _CharT __c);
+
+    basic_string& 
+    assign(const basic_string& __str);
+
+    basic_string& 
+    assign(const basic_string& __str, size_type __pos, size_type __n);
+    
+    basic_string& 
+    assign(const _CharT* __s, size_type __n);
+
+    basic_string& 
+    insert(size_type __pos1, const basic_string& __str);    
+
+    basic_string& 
+    insert(size_type __pos1, const basic_string& __str,
+	   size_type __pos2, size_type __n);
+
+    basic_string& 
+    insert(size_type __pos, const _CharT* __s, size_type __n);
+
+    basic_string& 
+    insert(size_type __pos, size_type __n, _CharT __c);
+
+    basic_string& 
+    erase(size_type __pos = 0, size_type __n = npos);
+
+    basic_string& 
+    replace(size_type __pos, size_type __n, const basic_string& __str);
+
+    basic_string& 
+    replace(size_type __pos1, size_type __n1, const basic_string& __str,
+	    size_type __pos2, size_type __n2);
+
+    basic_string& 
+    replace(size_type __pos, size_type __n1, const _CharT* __s,
+	    size_type __n2);
+
+    basic_string& 
+    replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c);
+
+
+    size_type 
+    copy(_CharT* __s, size_type __n, size_type __pos = 0) const;    
+
+    // String operations:
+    const _CharT* c_str() const;
+
+    size_type 
+    find(const _CharT* __s, size_type __pos, size_type __n) const;
+    
+    size_type 
+    find(const basic_string& __str, size_type __pos = 0) const;
+
+    size_type 
+    find(_CharT __c, size_type __pos = 0) const;
+
+    size_type 
+    rfind(const basic_string& __str, size_type __pos = npos) const;
+
+    size_type 
+    rfind(const _CharT* __s, size_type __pos, size_type __n) const;
+
+    size_type 
+    rfind(_CharT __c, size_type __pos = npos) const;
+
+    size_type 
+    find_first_of(const basic_string& __str, size_type __pos = 0) const;
+
+    size_type 
+    find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
+
+    size_type 
+    find_first_of(_CharT __c, size_type __pos = 0) const;
+
+    size_type 
+    find_last_of(const basic_string& __str, size_type __pos = npos) const;
+    
+    size_type 
+    find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
+
+    size_type 
+    find_last_of(_CharT __c, size_type __pos = npos) const;
+    
+    size_type 
+    find_first_not_of(const basic_string& __str, size_type __pos = 0) const;
+
+    size_type 
+    find_first_not_of(const _CharT* __s, size_type __pos, 
+		      size_type __n) const;
+
+    size_type 
+    find_first_not_of(_CharT __c, size_type __pos = 0) const;
+
+    size_type 
+    find_last_not_of(const basic_string& __str, size_type __pos = npos) const;
+
+    size_type 
+    find_last_not_of(const _CharT* __s, size_type __pos, 
+		     size_type __n) const;
+    
+    size_type 
+    find_last_not_of(_CharT __c, size_type __pos = npos) const;
+
+    basic_string 
+    substr(size_type __pos = 0, size_type __n = npos) const;
+
+    int 
+    compare(const basic_string& __str) const;
+
+    int 
+    compare(size_type __pos, size_type __n, const basic_string& __str) const;
+
+    int 
+    compare(size_type __pos1, size_type __n1, const basic_string& __str,
+	    size_type __pos2, size_type __n2) const;
+
+
+    %ignore pop_back();
+    %ignore front() const;
+    %ignore back() const;
+    %ignore basic_string(size_type n);
+    %std_sequence_methods_val(basic_string);    
+
+
+    %ignore pop();
+
+
+#ifdef %swig_basic_string
+    // Add swig/language extra methods
+    %swig_basic_string(std::basic_string< _CharT, _Traits, _Alloc >);
+#endif
+
+#ifdef SWIG_EXPORT_ITERATOR_METHODS
+
+    
+    class iterator;
+    class reverse_iterator;
+    class const_iterator;
+    class const_reverse_iterator;
+
+
+    void 
+    insert(iterator __p, size_type __n, _CharT __c);
+
+    basic_string& 
+    replace(iterator __i1, iterator __i2, const basic_string& __str);
+
+    basic_string& 
+    replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n);
+
+    basic_string& 
+    replace(iterator __i1, iterator __i2, size_type __n, _CharT __c);
+
+
+    basic_string& 
+    replace(iterator __i1, iterator __i2, const _CharT* __k1, const _CharT* __k2);
+
+    basic_string& 
+    replace(iterator __i1, iterator __i2, const_iterator __k1, const_iterator __k2);
+#endif
+
+    basic_string& operator +=(const basic_string& v);
+
+    %newobject __add__;   
+    %newobject __radd__;
+    %extend {
+
+      std::basic_string< _CharT,_Traits,_Alloc >* __add__(const basic_string& v) {
+	std::basic_string< _CharT,_Traits,_Alloc >* res = new std::basic_string< _CharT,_Traits,_Alloc >(*self);
+	*res += v;      
+	return res;
+      }
+      
+      std::basic_string< _CharT,_Traits,_Alloc >* __radd__(const basic_string& v) {
+	std::basic_string< _CharT,_Traits,_Alloc >* res = new std::basic_string< _CharT,_Traits,_Alloc >(v);
+	*res += *self;      
+	return res;
+      }
+      
+      std::basic_string< _CharT,_Traits,_Alloc > __str__() {
+	return *self;
+      }
+
+      std::basic_ostream<_CharT, std::char_traits<_CharT> >&
+	__rlshift__(std::basic_ostream<_CharT, std::char_traits<_CharT> >& out) {
+	out << *self;
+	return out;
+      }
+    }
+
+  };
+}
+
+
diff --git a/share/swig/2.0.11/std/std_carray.swg b/share/swig/3.0.12/std/std_carray.swg
index ebb20ce..ebb20ce 100644
--- a/share/swig/2.0.11/std/std_carray.swg
+++ b/share/swig/3.0.12/std/std_carray.swg
diff --git a/share/swig/2.0.11/std/std_char_traits.i b/share/swig/3.0.12/std/std_char_traits.i
index b9b4def..b9b4def 100644
--- a/share/swig/2.0.11/std/std_char_traits.i
+++ b/share/swig/3.0.12/std/std_char_traits.i
diff --git a/share/swig/3.0.12/std/std_common.i b/share/swig/3.0.12/std/std_common.i
new file mode 100644
index 0000000..05bc432
--- /dev/null
+++ b/share/swig/3.0.12/std/std_common.i
@@ -0,0 +1,250 @@
+%include <std/std_except.i>
+
+//
+// Use the following macro with modern STL implementations
+//
+//#define SWIG_STD_MODERN_STL
+//
+// Use this to deactive the previous definition, when using gcc-2.95
+// or similar old compilers.
+//
+//#define SWIG_STD_NOMODERN_STL
+
+// Here, we identify compilers we know have problems with STL.
+%{
+#if defined(__GNUC__)
+#  if __GNUC__ == 2 && __GNUC_MINOR <= 96
+#     define SWIG_STD_NOMODERN_STL
+#  endif
+#endif
+%}
+
+//
+// Common code for supporting the C++ std namespace
+//
+
+%fragment("<string>");
+%fragment("<stdexcept>");
+%fragment("<stddef.h>");
+
+
+%fragment("StdIteratorTraits","header",fragment="<stddef.h>") %{
+#if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
+#  if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
+#    define SWIG_STD_NOITERATOR_TRAITS_STL
+#  endif
+#endif
+
+#if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
+#include <iterator>
+#else
+namespace std {
+  template <class Iterator>
+  struct iterator_traits {
+    typedef ptrdiff_t difference_type;
+    typedef typename Iterator::value_type value_type;
+  };
+
+  template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
+  struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
+    typedef Distance difference_type;
+    typedef T value_type;
+  };
+
+  template <class T>
+  struct iterator_traits<T*> {
+    typedef T value_type;
+    typedef ptrdiff_t difference_type;
+  };
+
+  template<typename _InputIterator>
+  inline typename iterator_traits<_InputIterator>::difference_type
+  distance(_InputIterator __first, _InputIterator __last)
+  {
+    typename iterator_traits<_InputIterator>::difference_type __n = 0;
+    while (__first != __last) {
+      ++__first; ++__n;
+    }
+    return __n;
+  }
+}
+#endif
+%}
+
+%fragment("StdTraitsCommon","header",fragment="<string>") %{
+namespace swig {
+  template <class Type>
+  struct noconst_traits {
+    typedef Type noconst_type;
+  };
+
+  template <class Type>
+  struct noconst_traits<const Type> {
+    typedef Type noconst_type;
+  };
+
+  /*
+    type categories
+  */
+  struct pointer_category { };
+  struct value_category { };
+
+  /*
+    General traits that provides type_name and type_info
+  */
+  template <class Type> struct traits { };
+
+  template <class Type>
+  inline const char* type_name() {
+    return traits<typename noconst_traits<Type >::noconst_type >::type_name();
+  }
+
+  template <class Type> struct traits_info {
+    static swig_type_info *type_query(std::string name) {
+      name += " *";
+      return SWIG_TypeQuery(name.c_str());
+    }
+    static swig_type_info *type_info() {
+      static swig_type_info *info = type_query(type_name<Type>());
+      return info;
+    }
+  };
+
+  /*
+    Partial specialization for pointers (traits_info)
+  */
+  template <class Type> struct traits_info<Type *> {
+    static swig_type_info *type_query(std::string name) {
+      name += " *";
+      return SWIG_TypeQuery(name.c_str());
+    }
+    static swig_type_info *type_info() {
+      static swig_type_info *info = type_query(type_name<Type>());
+      return info;
+    }
+  };
+
+  template <class Type>
+  inline swig_type_info *type_info() {
+    return traits_info<Type>::type_info();
+  }
+
+  /*
+    Partial specialization for pointers (traits)
+  */
+  template <class Type> struct traits <Type *> {
+    typedef pointer_category category;
+    static std::string make_ptr_name(const char* name) {
+      std::string ptrname = name;
+      ptrname += " *";
+      return ptrname;
+    }
+    static const char* type_name() {
+      static std::string name = make_ptr_name(swig::type_name<Type>());
+      return name.c_str();
+    }
+  };
+
+  template <class Type, class Category>
+  struct traits_as { };
+
+  template <class Type, class Category>
+  struct traits_check { };
+
+}
+%}
+
+/*
+  Generate the traits for a swigtype
+*/
+
+%define %traits_swigtype(Type...)
+%fragment(SWIG_Traits_frag(Type),"header",fragment="StdTraits") {
+  namespace swig {
+    template <>  struct traits< Type > {
+      typedef pointer_category category;
+      static const char* type_name() { return  #Type; }
+    };
+  }
+}
+%enddef
+
+
+
+/*
+  Generate the typemaps for a class that has 'value' traits
+*/
+
+%define %typemap_traits(Code,Type...)
+  %typemaps_asvalfrom(%arg(Code),
+		     %arg(swig::asval< Type >),
+		     %arg(swig::from),
+		     %arg(SWIG_Traits_frag(Type)),
+		     %arg(SWIG_Traits_frag(Type)),
+		     Type);
+%enddef
+
+/*
+  Generate the typemaps for a class that behaves more like a 'pointer' or
+  plain wrapped Swigtype.
+*/
+
+%define %typemap_traits_ptr(Code,Type...)
+  %typemaps_asptrfrom(%arg(Code),
+		     %arg(swig::asptr),
+		     %arg(swig::from),
+		     %arg(SWIG_Traits_frag(Type)),
+		     %arg(SWIG_Traits_frag(Type)),
+		     Type);
+%enddef
+
+
+/*
+  Equality methods
+*/
+%define %std_equal_methods(Type...)
+%extend Type {
+  bool operator == (const Type& v) {
+    return *self == v;
+  }
+
+  bool operator != (const Type& v) {
+    return *self != v;
+  }
+}
+
+%enddef
+
+/*
+  Order methods
+*/
+
+%define %std_order_methods(Type...)
+%extend Type {
+  bool operator > (const Type& v) {
+    return *self > v;
+  }
+
+  bool operator < (const Type& v) {
+    return *self < v;
+  }
+
+  bool operator >= (const Type& v) {
+    return *self >= v;
+  }
+
+  bool operator <= (const Type& v) {
+    return *self <= v;
+  }
+}
+%enddef
+
+/*
+  Comparison methods
+*/
+
+%define %std_comp_methods(Type...)
+%std_equal_methods(Type )
+%std_order_methods(Type )
+%enddef
+
diff --git a/share/swig/3.0.12/std/std_container.i b/share/swig/3.0.12/std/std_container.i
new file mode 100644
index 0000000..000163f
--- /dev/null
+++ b/share/swig/3.0.12/std/std_container.i
@@ -0,0 +1,169 @@
+%include <std_common.i>
+%include <exception.i>
+%include <std_alloc.i>
+
+%{
+#include <algorithm>
+%}
+
+// Common non-resizable container methods
+
+%define %std_container_methods_non_resizable(container...)
+
+  container();
+  container(const container&);
+
+  bool empty() const;
+  size_type size() const;
+  void swap(container& v);
+
+%enddef
+
+%define %std_container_methods_forward_iterators(container...)
+
+  #ifdef SWIG_EXPORT_ITERATOR_METHODS
+  class iterator;
+  class const_iterator;
+  iterator begin();
+  iterator end();
+  #endif
+
+%enddef
+
+%define %std_container_methods_reverse_iterators(container...)
+
+  #ifdef SWIG_EXPORT_ITERATOR_METHODS
+  class reverse_iterator;
+  class const_reverse_iterator;
+  reverse_iterator rbegin();
+  reverse_iterator rend();
+  #endif
+
+%enddef
+
+// Common container methods
+
+%define %std_container_methods(container...)
+
+  %std_container_methods_non_resizable(%arg(container))
+  %std_container_methods_forward_iterators(%arg(container))
+  %std_container_methods_reverse_iterators(%arg(container))
+
+  void clear();
+  allocator_type get_allocator() const;
+
+%enddef
+
+%define %std_container_methods_without_reverse_iterators(container...)
+
+  %std_container_methods_non_resizable(%arg(container))
+  %std_container_methods_forward_iterators(%arg(container))
+
+  void clear();
+  allocator_type get_allocator() const;
+
+%enddef
+
+// Common sequence
+
+%define %std_sequence_methods_common(sequence)
+
+  %std_container_methods(%arg(sequence));
+
+  sequence(size_type size);
+  void pop_back();
+
+  void resize(size_type new_size);
+
+  #ifdef SWIG_EXPORT_ITERATOR_METHODS
+%extend {
+  // %extend wrapper used for differing definitions of these methods introduced in C++11
+  iterator erase(iterator pos) { return $self->erase(pos); }
+  iterator erase(iterator first, iterator last) { return $self->erase(first, last); }
+}
+  #endif
+
+%enddef
+
+%define %std_sequence_methods_non_resizable(sequence)
+
+  %std_container_methods_non_resizable(%arg(sequence))
+  %std_container_methods_forward_iterators(%arg(container))
+  %std_container_methods_reverse_iterators(%arg(container))
+
+  const value_type& front() const;
+  const value_type& back() const;
+
+%enddef
+
+%define %std_sequence_methods(sequence)
+
+  %std_sequence_methods_common(%arg(sequence));
+
+  sequence(size_type size, const value_type& value);
+  void push_back(const value_type& x);
+
+  const value_type& front() const;
+  const value_type& back() const;
+
+  void assign(size_type n, const value_type& x);
+  void resize(size_type new_size, const value_type& x);
+
+  #ifdef SWIG_EXPORT_ITERATOR_METHODS
+%extend {
+  // %extend wrapper used for differing definitions of these methods introduced in C++11
+  iterator insert(iterator pos, const value_type& x) { return $self->insert(pos, x); }
+  void insert(iterator pos, size_type n, const value_type& x) { $self->insert(pos, n, x); }
+}
+  #endif
+
+%enddef
+
+%define %std_sequence_methods_non_resizable_val(sequence...)
+
+  %std_container_methods_non_resizable(%arg(sequence))
+  %std_container_methods_forward_iterators(%arg(container))
+  %std_container_methods_reverse_iterators(%arg(container))
+
+  value_type front() const;
+  value_type back() const;
+
+#endif
+
+%enddef
+
+%define %std_sequence_methods_val(sequence...)
+
+  %std_sequence_methods_common(%arg(sequence));
+
+  sequence(size_type size, value_type value);
+  void push_back(value_type x);
+
+  value_type front() const;
+  value_type back() const;
+
+  void assign(size_type n, value_type x);
+  void resize(size_type new_size, value_type x);
+
+  #ifdef SWIG_EXPORT_ITERATOR_METHODS
+%extend {
+  // %extend wrapper used for differing definitions of these methods introduced in C++11
+  iterator insert(iterator pos, value_type x) { return $self->insert(pos, x); }
+  void insert(iterator pos, size_type n, value_type x) { $self->insert(pos, n, x); }
+}
+  #endif
+
+%enddef
+
+
+//
+// Ignore member methods for Type with no default constructor
+//
+%define %std_nodefconst_type(Type...)
+%feature("ignore") std::vector< Type >::vector(size_type size);
+%feature("ignore") std::vector< Type >::resize(size_type size);
+%feature("ignore") std::deque< Type >::deque(size_type size);
+%feature("ignore") std::deque< Type >::resize(size_type size);
+%feature("ignore") std::list< Type >::list(size_type size);
+%feature("ignore") std::list< Type >::resize(size_type size);
+%enddef
diff --git a/share/swig/3.0.12/std/std_deque.i b/share/swig/3.0.12/std/std_deque.i
new file mode 100644
index 0000000..aa5536b
--- /dev/null
+++ b/share/swig/3.0.12/std/std_deque.i
@@ -0,0 +1,127 @@
+//
+// std::deque
+
+%include <std_container.i>
+
+// Deque
+
+%define %std_deque_methods(deque...)  
+  %std_sequence_methods(deque)
+
+  void pop_front();
+  void push_front(const value_type& x);
+%enddef
+
+%define %std_deque_methods_val(deque...)
+  %std_sequence_methods_val(deque)
+
+  void pop_front();
+  void push_front(value_type x);
+%enddef
+
+// ------------------------------------------------------------------------
+// std::deque
+// 
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+// 
+//   -- f(std::deque<T>), f(const std::deque<T>&):
+//      the parameter being read-only, either a sequence or a
+//      previously wrapped std::deque<T> can be passed.
+//   -- f(std::deque<T>&), f(std::deque<T>*):
+//      the parameter may be modified; therefore, only a wrapped std::deque
+//      can be passed.
+//   -- std::deque<T> f(), const std::deque<T>& f():
+//      the deque is returned by copy; therefore, a sequence of T:s 
+//      is returned which is most easily used in other functions
+//   -- std::deque<T>& f(), std::deque<T>* f():
+//      the deque is returned by reference; therefore, a wrapped std::deque
+//      is returned
+//   -- const std::deque<T>* f(), f(const std::deque<T>*):
+//      for consistency, they expect and return a plain deque pointer.
+// ------------------------------------------------------------------------
+
+%{
+#include <deque>
+%}
+
+// exported classes
+
+namespace std {
+
+  template<class _Tp, class _Alloc = allocator< _Tp > >
+  class deque {
+  public:
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef _Tp 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;
+
+    %traits_swigtype(_Tp);
+
+    %fragment(SWIG_Traits_frag(std::deque< _Tp, _Alloc >), "header",
+	      fragment=SWIG_Traits_frag(_Tp),
+	      fragment="StdDequeTraits") {
+      namespace swig {
+	template <>  struct traits<std::deque< _Tp, _Alloc > > {
+	  typedef pointer_category category;
+	  static const char* type_name() {
+	    return "std::deque<" #_Tp " >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_DEQUE, std::deque< _Tp, _Alloc >);
+  
+#ifdef %swig_deque_methods
+    // Add swig/language extra methods
+    %swig_deque_methods(std::deque< _Tp, _Alloc >);
+#endif
+
+    %std_deque_methods(deque);
+  };
+
+  template<class _Tp, class _Alloc > 
+  class deque< _Tp*, _Alloc > {
+  public:
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef _Tp* value_type;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef value_type reference;
+    typedef value_type const_reference;
+    typedef _Alloc allocator_type;
+
+    %traits_swigtype(_Tp);
+
+    %fragment(SWIG_Traits_frag(std::deque< _Tp*, _Alloc >), "header",
+	      fragment=SWIG_Traits_frag(_Tp),
+	      fragment="StdDequeTraits") {
+      namespace swig {
+	template <>  struct traits<std::deque< _Tp*, _Alloc > > {
+	  typedef value_category category;
+	  static const char* type_name() {
+	    return "std::deque<" #_Tp " * >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_DEQUE, std::deque< _Tp*, _Alloc >);
+
+#ifdef %swig_deque_methods_val
+    // Add swig/language extra methods
+    %swig_deque_methods_val(std::deque< _Tp*, _Alloc >);
+#endif
+
+    %std_deque_methods_val(deque);
+  };
+
+}
+
diff --git a/share/swig/3.0.12/std/std_except.i b/share/swig/3.0.12/std/std_except.i
new file mode 100644
index 0000000..728b9c8
--- /dev/null
+++ b/share/swig/3.0.12/std/std_except.i
@@ -0,0 +1,73 @@
+#if defined(SWIGJAVA) || defined(SWIGCSHARP)
+#error "do not use this version of std_except.i"
+#endif
+
+%{
+#include <typeinfo>
+#include <stdexcept>
+%}
+
+#if defined(SWIG_STD_EXCEPTIONS_AS_CLASSES)
+
+namespace std {
+  struct exception 
+  {
+    virtual ~exception() throw();
+    virtual const char* what() const throw();
+  };
+
+  struct bad_cast : exception 
+  {
+  };
+
+  struct bad_exception : exception 
+  {
+  };
+
+  struct logic_error : exception 
+  {
+    logic_error(const string& msg);
+  };
+
+  struct domain_error : logic_error 
+  {
+    domain_error(const string& msg);
+  };
+
+  struct invalid_argument : logic_error 
+  {
+    invalid_argument(const string& msg);
+  };
+
+  struct length_error : logic_error 
+  {
+    length_error(const string& msg);
+  };
+
+  struct out_of_range : logic_error 
+  {
+    out_of_range(const string& msg);
+  };
+
+  struct runtime_error : exception 
+  {
+    runtime_error(const string& msg);
+  };
+
+  struct range_error : runtime_error 
+  {
+    range_error(const string& msg);
+  };
+
+  struct overflow_error : runtime_error 
+  {
+    overflow_error(const string& msg);
+  };
+
+  struct underflow_error : runtime_error 
+  {
+    underflow_error(const string& msg);
+  };
+}
+
+#endif
diff --git a/share/swig/3.0.12/std/std_ios.i b/share/swig/3.0.12/std/std_ios.i
new file mode 100644
index 0000000..db83c7a
--- /dev/null
+++ b/share/swig/3.0.12/std/std_ios.i
@@ -0,0 +1,262 @@
+%include <std_char_traits.i>
+%include <std_basic_string.i>
+%include <std_except.i>
+%{
+#ifndef SWIG_STD_NOMODERN_STL
+# include <ios>
+#else
+# include <streambuf.h>
+#endif
+%}
+
+namespace std {
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+  class basic_streambuf;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+  class basic_istream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+  class basic_ostream;
+
+  // 27.4.2  Class ios_base
+  typedef size_t streamsize;
+
+  class locale;
+  
+  
+  class ios_base
+  {
+  public:
+    
+#ifdef SWIG_NESTED_CLASSES
+    // 27.4.2.1.1  Class ios_base::failure
+    class failure : public exception
+    {
+    public:
+      explicit failure(const string& __str) throw();
+    };
+#endif
+
+    // 27.4.2.1.2  Type ios_base::fmtflags
+    typedef int fmtflags;
+    // 27.4.2.1.2  Type fmtflags
+    static const fmtflags boolalpha ;
+    static const fmtflags dec ;
+    static const fmtflags fixed ;
+    static const fmtflags hex ;
+    static const fmtflags internal ;
+    static const fmtflags left ;
+    static const fmtflags oct ;
+    static const fmtflags right ;
+    static const fmtflags scientific ;
+    static const fmtflags showbase ;
+    static const fmtflags showpoint ;
+    static const fmtflags showpos ;
+    static const fmtflags skipws ;
+    static const fmtflags unitbuf ;
+    static const fmtflags uppercase ;
+    static const fmtflags adjustfield ;
+    static const fmtflags basefield ;
+    static const fmtflags floatfield ;
+
+    // 27.4.2.1.3  Type ios_base::iostate
+    typedef int iostate;
+    static const iostate badbit ;
+    static const iostate eofbit ;
+    static const iostate failbit ;
+    static const iostate goodbit ;
+
+    // 27.4.2.1.4  Type openmode
+    typedef int openmode;
+    static const openmode app ;
+    static const openmode ate ;
+    static const openmode binary ;
+    static const openmode in ;
+    static const openmode out ;
+    static const openmode trunc ;
+
+    // 27.4.2.1.5  Type seekdir
+    typedef int seekdir;
+    static const seekdir beg ;
+    static const seekdir cur ;
+    static const seekdir end ;
+
+
+    // Callbacks;
+    enum event
+      {
+	erase_event,
+	imbue_event,
+	copyfmt_event
+      };
+
+    typedef void (*event_callback) (event, ios_base&, int);
+
+    void 
+    register_callback(event_callback __fn, int __index);
+
+    // Fmtflags state:
+    inline fmtflags 
+    flags() const ;
+
+    inline fmtflags 
+    flags(fmtflags __fmtfl);
+
+    inline fmtflags 
+    setf(fmtflags __fmtfl);
+
+    inline fmtflags 
+    setf(fmtflags __fmtfl, fmtflags __mask);
+
+    inline void 
+    unsetf(fmtflags __mask) ;
+
+    inline streamsize 
+    precision() const ;
+
+    inline streamsize 
+    precision(streamsize __prec);
+
+    inline streamsize 
+    width() const ;
+
+    inline streamsize 
+    width(streamsize __wide);
+
+    static bool 
+    sync_with_stdio(bool __sync = true);
+
+    // Locales:
+    locale 
+    imbue(const locale& __loc);
+
+    inline locale 
+    getloc() const { return _M_ios_locale; }
+
+    // Storage:
+    static int 
+    xalloc() throw();
+
+    inline long& 
+    iword(int __ix);
+
+    inline void*& 
+    pword(int __ix);
+
+    // Destructor
+    ~ios_base();
+
+  protected:
+    ios_base();
+
+  //50.  Copy constructor and assignment operator of ios_base
+  private:
+    ios_base(const ios_base&);
+
+    ios_base& 
+    operator=(const ios_base&);
+  };
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+  class basic_ios : public ios_base
+  {
+  public:
+    // Types:
+    typedef _CharT 				char_type;
+    typedef typename _Traits::int_type 	int_type;
+    typedef typename _Traits::pos_type 	pos_type;
+    typedef typename _Traits::off_type 	off_type;
+    typedef _Traits 				traits_type;
+      
+  public:
+
+    iostate 
+    rdstate() const;
+
+    void 
+    clear(iostate __state = goodbit);
+
+    void 
+    setstate(iostate __state);
+
+    bool 
+    good() const;
+
+    bool 
+    eof() const;
+
+    bool 
+    fail() const;
+
+    bool 
+    bad() const;
+
+    iostate 
+    exceptions() const;
+
+    void 
+    exceptions(iostate __except);
+
+    // Constructor/destructor:
+    explicit 
+    basic_ios(basic_streambuf<_CharT, _Traits>* __sb) : ios_base();
+
+    virtual 
+    ~basic_ios() ;
+      
+    // Members:
+    basic_ostream<_CharT, _Traits>*
+    tie() const;
+
+    basic_ostream<_CharT, _Traits>*
+    tie(basic_ostream<_CharT, _Traits>* __tiestr);
+
+    basic_streambuf<_CharT, _Traits>*
+    rdbuf() const;
+
+    basic_streambuf<_CharT, _Traits>* 
+    rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
+
+    basic_ios&
+    copyfmt(const basic_ios& __rhs);
+
+    char_type 
+    fill() const;
+
+    char_type 
+    fill(char_type __ch);
+
+    // Locales:
+    locale 
+    imbue(const locale& __loc);
+
+    char 
+    narrow(char_type __c, char __dfault) const;
+
+    char_type 
+    widen(char __c) const;
+     
+  protected:
+    // 27.4.5.1  basic_ios constructors
+    basic_ios();
+  private:
+    basic_ios(const basic_ios&);
+
+    basic_ios&
+    operator=(const basic_ios&);
+  };
+  
+}
+
+namespace std {
+  typedef basic_ios<char> ios;
+  %template(ios) basic_ios<char>;
+#if defined(SWIG_WCHAR)
+ typedef basic_ios<wchar_t> wios;
+  %template(wios) basic_ios<wchar_t>;
+#endif
+}
+
+  
diff --git a/share/swig/2.0.11/std/std_iostream.i b/share/swig/3.0.12/std/std_iostream.i
index 7a33afe..7a33afe 100644
--- a/share/swig/2.0.11/std/std_iostream.i
+++ b/share/swig/3.0.12/std/std_iostream.i
diff --git a/share/swig/3.0.12/std/std_list.i b/share/swig/3.0.12/std/std_list.i
new file mode 100644
index 0000000..ebbafa2
--- /dev/null
+++ b/share/swig/3.0.12/std/std_list.i
@@ -0,0 +1,148 @@
+//
+// std::list
+//
+
+%include <std_container.i>
+
+// List
+
+%define %std_list_methods(list...)
+  %std_sequence_methods(list)
+  
+  void pop_front();
+  void push_front(const value_type& x);
+  		
+  void reverse();
+  
+%enddef
+
+
+%define %std_list_methods_val(list...)
+  %std_sequence_methods_val(list)
+  
+  void pop_front();
+  void push_front(value_type x);
+  		
+  void remove(value_type x);
+  void unique();
+  void reverse();
+  void sort();
+  
+  void merge(list& x);
+%enddef
+
+// ------------------------------------------------------------------------
+// std::list
+// 
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+// 
+//   -- f(std::list<T>), f(const std::list<T>&):
+//      the parameter being read-only, either a sequence or a
+//      previously wrapped std::list<T> can be passed.
+//   -- f(std::list<T>&), f(std::list<T>*):
+//      the parameter may be modified; therefore, only a wrapped std::list
+//      can be passed.
+//   -- std::list<T> f(), const std::list<T>& f():
+//      the list is returned by copy; therefore, a sequence of T:s 
+//      is returned which is most easily used in other functions
+//   -- std::list<T>& f(), std::list<T>* f():
+//      the list is returned by reference; therefore, a wrapped std::list
+//      is returned
+//   -- const std::list<T>* f(), f(const std::list<T>*):
+//      for consistency, they expect and return a plain list pointer.
+// ------------------------------------------------------------------------
+
+%{
+#include <list>
+%}
+
+// exported classes
+
+namespace std {
+
+  template<class _Tp, class _Alloc = allocator< _Tp > >
+  class list {
+  public:
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef _Tp 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;
+
+    %traits_swigtype(_Tp);
+
+    %fragment(SWIG_Traits_frag(std::list< _Tp, _Alloc >), "header",
+	      fragment=SWIG_Traits_frag(_Tp),
+	      fragment="StdListTraits") {
+      namespace swig {
+	template <>  struct traits<std::list< _Tp, _Alloc > > {
+	  typedef pointer_category category;
+	  static const char* type_name() {
+	    return "std::list<" #_Tp ", " #_Alloc " >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_LIST, std::list< _Tp, _Alloc >);
+
+#ifdef %swig_list_methods
+    // Add swig/language extra methods
+    %swig_list_methods(std::list< _Tp, _Alloc >);
+#endif
+  
+    %std_list_methods(list);
+  };
+
+  template<class _Tp, class _Alloc >
+  class list< _Tp*, _Alloc> {
+  public:
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef _Tp* value_type;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef value_type reference;
+    typedef value_type const_reference;
+    typedef _Alloc allocator_type;
+
+    %traits_swigtype(_Tp);
+
+    %fragment(SWIG_Traits_frag(std::list< _Tp*, _Alloc >), "header",
+	      fragment=SWIG_Traits_frag(_Tp),
+	      fragment="StdListTraits") {
+      namespace swig {
+	template <>  struct traits<std::list< _Tp*, _Alloc > > {
+	  typedef value_category category;
+	  static const char* type_name() {
+	    return "std::list<" #_Tp " *," #_Alloc " >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_LIST, std::list< _Tp*, _Alloc >);
+
+#ifdef %swig_list_methods_val
+    // Add swig/language extra methods
+    %swig_list_methods_val(std::list< _Tp*, _Alloc >);
+#endif
+
+    %std_list_methods_val(list);
+  };
+
+}
+
+%define %std_extequal_list(...)
+%extend std::list< __VA_ARGS__ > {
+  void remove(const value_type& x) { self->remove(x); }  
+  void merge(std::list< __VA_ARGS__ >& x){ self->merge(x); }
+  void unique() { self->unique(); }  
+  void sort() { self->sort(); }  
+}
+%enddef
+
diff --git a/share/swig/3.0.12/std/std_map.i b/share/swig/3.0.12/std/std_map.i
new file mode 100644
index 0000000..8043f92
--- /dev/null
+++ b/share/swig/3.0.12/std/std_map.i
@@ -0,0 +1,126 @@
+//
+// std::map
+//
+
+%include <std_pair.i>
+%include <std_container.i>
+
+%define %std_map_methods_common(map...)
+  %std_container_methods(map);
+
+  size_type erase(const key_type& x);
+  size_type count(const key_type& x) const;
+
+#ifdef SWIG_EXPORT_ITERATOR_METHODS
+%extend {
+  // %extend wrapper used for differing definitions of these methods introduced in C++11
+  void erase(iterator position) { $self->erase(position); }
+  void erase(iterator first, iterator last) { $self->erase(first, last); }
+}
+
+  iterator find(const key_type& x);
+  iterator lower_bound(const key_type& x);
+  iterator upper_bound(const key_type& x);
+#endif
+%enddef
+
+%define %std_map_methods(map...)
+  %std_map_methods_common(map);
+
+  #ifdef SWIG_EXPORT_ITERATOR_METHODS
+//  iterator insert(const value_type& x);
+  #endif
+%enddef
+
+
+// ------------------------------------------------------------------------
+// std::map
+// 
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+// 
+//   -- f(std::map<T>), f(const std::map<T>&):
+//      the parameter being read-only, either a sequence or a
+//      previously wrapped std::map<T> can be passed.
+//   -- f(std::map<T>&), f(std::map<T>*):
+//      the parameter may be modified; therefore, only a wrapped std::map
+//      can be passed.
+//   -- std::map<T> f(), const std::map<T>& f():
+//      the map is returned by copy; therefore, a sequence of T:s 
+//      is returned which is most easily used in other functions
+//   -- std::map<T>& f(), std::map<T>* f():
+//      the map is returned by reference; therefore, a wrapped std::map
+//      is returned
+//   -- const std::map<T>* f(), f(const std::map<T>*):
+//      for consistency, they expect and return a plain map pointer.
+// ------------------------------------------------------------------------
+
+%{
+#include <map>
+%}
+%fragment("<algorithm>");
+%fragment("<stdexcept>");
+
+// exported class
+
+namespace std {
+
+  template<class _Key, class _Tp, class _Compare = std::less<_Key >,
+	   class _Alloc = allocator<std::pair< const _Key, _Tp > > >
+  class map {
+  public:
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef _Key key_type;
+    typedef _Tp mapped_type;
+    typedef std::pair< const _Key, _Tp > 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;
+
+    %traits_swigtype(_Key);
+    %traits_swigtype(_Tp);	    
+
+    %fragment(SWIG_Traits_frag(std::pair< _Key, _Tp >), "header",
+	      fragment=SWIG_Traits_frag(_Key),
+	      fragment=SWIG_Traits_frag(_Tp),
+	      fragment="StdPairTraits") {
+      namespace swig {
+	template <>  struct traits<std::pair< _Key, _Tp > > {
+	  typedef pointer_category category;
+	  static const char* type_name() {
+	    return "std::pair<" #_Key "," #_Tp " >";
+	  }
+	};
+      }
+    }
+
+    %fragment(SWIG_Traits_frag(std::map< _Key, _Tp, _Compare, _Alloc >), "header",
+	      fragment=SWIG_Traits_frag(std::pair< _Key, _Tp >),
+	      fragment="StdMapTraits") {
+      namespace swig {
+	template <>  struct traits<std::map< _Key, _Tp, _Compare, _Alloc > > {
+	  typedef pointer_category category;
+	  static const char* type_name() {
+	    return "std::map<" #_Key "," #_Tp "," #_Compare "," #_Alloc " >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_MAP, std::map< _Key, _Tp, _Compare, _Alloc >);
+
+    map( const _Compare& );
+
+#ifdef %swig_map_methods
+    // Add swig/language extra methods
+    %swig_map_methods(std::map< _Key, _Tp, _Compare, _Alloc >);
+#endif
+  
+    %std_map_methods(map);
+  };
+
+}
diff --git a/share/swig/3.0.12/std/std_multimap.i b/share/swig/3.0.12/std/std_multimap.i
new file mode 100644
index 0000000..7aa9499
--- /dev/null
+++ b/share/swig/3.0.12/std/std_multimap.i
@@ -0,0 +1,101 @@
+//
+// std::multimap
+//
+
+%include <std_map.i>
+
+
+%define %std_multimap_methods(mmap...)
+  %std_map_methods_common(mmap);
+
+#ifdef SWIG_EXPORT_ITERATOR_METHODS
+  std::pair<iterator,iterator> equal_range(const key_type& x);
+  std::pair<const_iterator,const_iterator> equal_range(const key_type& x) const;
+#endif
+%enddef
+
+// ------------------------------------------------------------------------
+// std::multimap
+// 
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+// 
+//   -- f(std::multimap<T>), f(const std::multimap<T>&):
+//      the parameter being read-only, either a sequence or a
+//      previously wrapped std::multimap<T> can be passed.
+//   -- f(std::multimap<T>&), f(std::multimap<T>*):
+//      the parameter may be modified; therefore, only a wrapped std::multimap
+//      can be passed.
+//   -- std::multimap<T> f(), const std::multimap<T>& f():
+//      the map is returned by copy; therefore, a sequence of T:s 
+//      is returned which is most easily used in other functions
+//   -- std::multimap<T>& f(), std::multimap<T>* f():
+//      the map is returned by reference; therefore, a wrapped std::multimap
+//      is returned
+//   -- const std::multimap<T>* f(), f(const std::multimap<T>*):
+//      for consistency, they expect and return a plain map pointer.
+// ------------------------------------------------------------------------
+
+
+// exported class
+
+
+namespace std {
+  template<class _Key, class _Tp, class _Compare = std::less< _Key >,
+	   class _Alloc = allocator<std::pair< const _Key, _Tp > > >
+  class multimap {
+  public:
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef _Key key_type;
+    typedef _Tp mapped_type;
+    typedef std::pair< const _Key, _Tp > 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;
+
+    %traits_swigtype(_Key);
+    %traits_swigtype(_Tp);	    
+
+    %fragment(SWIG_Traits_frag(std::pair< _Key, _Tp >), "header",
+	      fragment=SWIG_Traits_frag(_Key),
+	      fragment=SWIG_Traits_frag(_Tp),
+	      fragment="StdPairTraits") {
+      namespace swig {
+	template <>  struct traits<std::pair< _Key, _Tp > > {
+	  typedef pointer_category category;
+	  static const char* type_name() {
+	    return "std::pair<" #_Key "," #_Tp " >";
+	  }
+	};
+      }
+    }
+
+    %fragment(SWIG_Traits_frag(std::multimap< _Key, _Tp, _Compare, _Alloc >), "header",
+	      fragment=SWIG_Traits_frag(std::pair< _Key, _Tp >),
+	      fragment="StdMultimapTraits") {
+      namespace swig {
+	template <>  struct traits<std::multimap< _Key, _Tp, _Compare, _Alloc > > {
+	  typedef pointer_category category;
+	  static const char* type_name() {
+	    return "std::multimap<" #_Key "," #_Tp "," #_Compare "," #_Alloc " >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_MULTIMAP, std::multimap< _Key, _Tp, _Compare, _Alloc >);
+  
+    multimap( const _Compare& );
+
+#ifdef %swig_multimap_methods
+    // Add swig/language extra methods
+    %swig_multimap_methods(std::multimap< _Key, _Tp, _Compare, _Alloc >);
+#endif
+
+    %std_multimap_methods(multimap);
+  };
+}
diff --git a/share/swig/3.0.12/std/std_multiset.i b/share/swig/3.0.12/std/std_multiset.i
new file mode 100644
index 0000000..1aa7ccc
--- /dev/null
+++ b/share/swig/3.0.12/std/std_multiset.i
@@ -0,0 +1,83 @@
+//
+// std::multiset
+//
+
+%include <std_set.i>
+
+// Multiset
+
+%define %std_multiset_methods(multiset...)
+  %std_set_methods_common(multiset);
+%enddef
+
+
+// ------------------------------------------------------------------------
+// std::multiset
+// 
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+// 
+//   -- f(std::multiset<T>), f(const std::multiset<T>&):
+//      the parameter being read-only, either a sequence or a
+//      previously wrapped std::multiset<T> can be passed.
+//   -- f(std::multiset<T>&), f(std::multiset<T>*):
+//      the parameter may be modified; therefore, only a wrapped std::multiset
+//      can be passed.
+//   -- std::multiset<T> f(), const std::multiset<T>& f():
+//      the set is returned by copy; therefore, a sequence of T:s 
+//      is returned which is most easily used in other functions
+//   -- std::multiset<T>& f(), std::multiset<T>* f():
+//      the set is returned by reference; therefore, a wrapped std::multiset
+//      is returned
+//   -- const std::multiset<T>* f(), f(const std::multiset<T>*):
+//      for consistency, they expect and return a plain set pointer.
+// ------------------------------------------------------------------------
+
+
+// exported classes
+
+namespace std {
+
+  //multiset
+
+  template <class _Key, class _Compare = std::less< _Key >,
+	    class _Alloc = allocator< _Key > >
+  class multiset {
+  public:
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef _Key value_type;
+    typedef _Key key_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;
+
+    %traits_swigtype(_Key);
+
+    %fragment(SWIG_Traits_frag(std::multiset< _Key, _Compare, _Alloc >), "header",
+	      fragment=SWIG_Traits_frag(_Key),
+	      fragment="StdMultisetTraits") {
+      namespace swig {
+	template <>  struct traits<std::multiset< _Key, _Compare, _Alloc > > {
+	  typedef pointer_category category;
+	  static const char* type_name() {
+	    return "std::multiset<" #_Key "," #_Compare "," #_Alloc " >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_MULTISET, std::multiset< _Key, _Compare, _Alloc >);
+
+    multiset( const _Compare& );
+
+#ifdef %swig_multiset_methods
+    // Add swig/language extra methods
+    %swig_multiset_methods(std::multiset< _Key, _Compare, _Alloc >);
+#endif
+  
+    %std_multiset_methods(multiset);
+  };
+}
diff --git a/share/swig/3.0.12/std/std_pair.i b/share/swig/3.0.12/std/std_pair.i
new file mode 100644
index 0000000..001cd67
--- /dev/null
+++ b/share/swig/3.0.12/std/std_pair.i
@@ -0,0 +1,163 @@
+%include <std_common.i>
+
+%{
+#include <utility>
+%}
+
+
+namespace std {
+  template <class T, class U > struct pair {      
+    typedef T first_type;
+    typedef U second_type;
+    
+    %traits_swigtype(T);
+    %traits_swigtype(U);
+
+    %fragment(SWIG_Traits_frag(std::pair< T, U >), "header",
+	      fragment=SWIG_Traits_frag(T),
+	      fragment=SWIG_Traits_frag(U),
+	      fragment="StdPairTraits") {
+      namespace swig {
+	template <>  struct traits<std::pair< T, U > > {
+	  typedef pointer_category category;
+	  static const char* type_name() {
+	    return "std::pair<" #T "," #U " >";
+	  }
+	};
+      }
+    }
+
+#ifndef SWIG_STD_PAIR_ASVAL
+    %typemap_traits_ptr(SWIG_TYPECHECK_PAIR, std::pair< T, U >);
+#else
+    %typemap_traits(SWIG_TYPECHECK_PAIR, std::pair< T, U >);
+#endif
+
+    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;
+
+#ifdef %swig_pair_methods
+    // Add swig/language extra methods
+    %swig_pair_methods(std::pair< T, U >)
+#endif
+  };
+
+  // ***
+  // The following specializations should disappear or get
+  // simplified when a 'const SWIGTYPE*&' can be defined
+  // ***
+  template <class T, class U > struct pair< T, U* > {
+    typedef T first_type;
+    typedef U* second_type;
+    
+    %traits_swigtype(T);
+    %traits_swigtype(U);
+      
+    %fragment(SWIG_Traits_frag(std::pair< T, U* >), "header",
+	      fragment=SWIG_Traits_frag(T),
+	      fragment=SWIG_Traits_frag(U),
+	      fragment="StdPairTraits") {
+      namespace swig {
+	template <>  struct traits<std::pair< T, U* > > {
+	  typedef pointer_category category;
+	  static const char* type_name() {
+	    return "std::pair<" #T "," #U " * >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_PAIR, std::pair< T, U* >);
+
+    pair();
+    pair(T __a, U* __b);
+    pair(const pair& __p);
+
+    T first;
+    U* second;
+
+#ifdef %swig_pair_methods
+    // Add swig/language extra methods
+    %swig_pair_methods(std::pair< T, U* >)
+#endif
+  };
+
+  template <class T, class U > struct pair< T*, U > {
+    typedef T* first_type;
+    typedef U second_type;
+    
+    %traits_swigtype(T);
+    %traits_swigtype(U);
+      
+    %fragment(SWIG_Traits_frag(std::pair< T*, U >), "header",
+	      fragment=SWIG_Traits_frag(T),
+	      fragment=SWIG_Traits_frag(U),
+	      fragment="StdPairTraits") {
+      namespace swig {
+	template <>  struct traits<std::pair< T*, U > > {
+	  typedef pointer_category category;
+	  static const char* type_name() {
+	    return "std::pair<" #T " *," #U " >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_PAIR, std::pair< T*, U >);
+
+    pair();
+    pair(T* __a, U __b);
+    pair(const pair& __p);
+
+    T* first;
+    U second;
+
+#ifdef %swig_pair_methods
+    // Add swig/language extra methods
+    %swig_pair_methods(std::pair< T*, U >)
+#endif
+  };
+
+  template <class T, class U > struct pair< T*, U* > {
+    typedef T* first_type;
+    typedef U* second_type;
+
+    %traits_swigtype(T);
+    %traits_swigtype(U);
+      
+    %fragment(SWIG_Traits_frag(std::pair< T*, U* >), "header",
+	      fragment=SWIG_Traits_frag(T),
+	      fragment=SWIG_Traits_frag(U),
+	      fragment="StdPairTraits") {
+      namespace swig {
+	template <>  struct traits<std::pair< T*, U* > > {
+	  typedef pointer_category category;
+	  static const char* type_name() {
+	    return "std::pair<" #T " *," #U " * >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits(SWIG_TYPECHECK_PAIR, std::pair< T*, U* >);
+
+    pair();
+    pair(T* __a, U* __b);
+    pair(const pair& __p);
+
+    T* first;
+    U* second;
+ 
+#ifdef %swig_pair_methods
+    // Add swig/language extra methods
+    %swig_pair_methods(std::pair< T*, U* >)
+#endif
+  };
+
+}
diff --git a/share/swig/3.0.12/std/std_queue.i b/share/swig/3.0.12/std/std_queue.i
new file mode 100644
index 0000000..b2c8d8d
--- /dev/null
+++ b/share/swig/3.0.12/std/std_queue.i
@@ -0,0 +1,129 @@
+/**
+ * @file   std_queue.i
+ * @date   Sun May  6 01:48:07 2007
+ * 
+ * @brief  A wrapping of std::queue for Ruby.
+ * 
+ * 
+ */
+
+%include <std_container.i>
+
+// Queue
+
+%define %std_queue_methods(queue...)
+  queue();
+  queue( const _Sequence& );
+
+  bool empty() const;
+  size_type size() const;
+  const value_type& front() const;
+  const value_type& back() const;
+  void pop();
+  void push( const value_type& );
+%enddef
+
+%define %std_queue_methods_val(queue...) 
+  %std_queue_methods(queue)
+%enddef
+
+// ------------------------------------------------------------------------
+// std::queue
+// 
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+// 
+//   -- f(std::queue<T>), f(const std::queue<T>&):
+//      the parameter being read-only, either a sequence or a
+//      previously wrapped std::queue<T> can be passed.
+//   -- f(std::queue<T>&), f(std::queue<T>*):
+//      the parameter may be modified; therefore, only a wrapped std::queue
+//      can be passed.
+//   -- std::queue<T> f(), const std::queue<T>& f():
+//      the queue is returned by copy; therefore, a sequence of T:s 
+//      is returned which is most easily used in other functions
+//   -- std::queue<T>& f(), std::queue<T>* f():
+//      the queue is returned by reference; therefore, a wrapped std::queue
+//      is returned
+//   -- const std::queue<T>* f(), f(const std::queue<T>*):
+//      for consistency, they expect and return a plain queue pointer.
+// ------------------------------------------------------------------------
+
+%{
+#include <queue>
+%}
+
+// exported classes
+
+namespace std {
+
+  template<class _Tp, class _Sequence = std::deque< _Tp > >
+  class queue {
+  public:
+    typedef size_t size_type;
+    typedef _Tp value_type;
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
+    typedef _Sequence container_type;
+
+    %traits_swigtype(_Tp);
+
+    %fragment(SWIG_Traits_frag(std::queue< _Tp, _Sequence >), "header",
+	      fragment=SWIG_Traits_frag(_Tp),
+	      fragment="StdQueueTraits") {
+      namespace swig {
+	template <>  struct traits<std::queue< _Tp, _Sequence > > {
+	  typedef pointer_category category;
+	  static const char* type_name() {
+	    return "std::queue<" #_Tp "," #_Sequence " >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_QUEUE, std::queue< _Tp, _Sequence >);
+  
+#ifdef %swig_queue_methods
+    // Add swig/language extra methods
+    %swig_queue_methods(std::queue< _Tp, _Sequence >);
+#endif
+
+    %std_queue_methods(queue);
+  };
+
+  template<class _Tp, class _Sequence > 
+  class queue< _Tp*, _Sequence > {
+  public:
+    typedef size_t size_type;
+    typedef _Tp value_type;
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
+    typedef _Sequence container_type;
+
+    %traits_swigtype(_Tp);
+
+    %fragment(SWIG_Traits_frag(std::queue< _Tp*, _Sequence >), "header",
+	      fragment=SWIG_Traits_frag(_Tp),
+	      fragment="StdQueueTraits") {
+      namespace swig {
+	template <>  struct traits<std::queue< _Tp*, _Sequence > > {
+	  typedef value_category category;
+	  static const char* type_name() {
+	    return "std::queue<" #_Tp "," #_Sequence " * >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_QUEUE, std::queue< _Tp*, _Sequence >);
+
+#ifdef %swig_queue_methods_val
+    // Add swig/language extra methods
+    %swig_queue_methods_val(std::queue< _Tp*, _Sequence >);
+#endif
+
+    %std_queue_methods_val(queue);
+  };
+
+}
+
diff --git a/share/swig/3.0.12/std/std_set.i b/share/swig/3.0.12/std/std_set.i
new file mode 100644
index 0000000..107a23c
--- /dev/null
+++ b/share/swig/3.0.12/std/std_set.i
@@ -0,0 +1,122 @@
+//
+// std::set
+//
+
+%include <std_container.i>
+%include <std_pair.i>
+
+// Set
+%define %std_set_methods_common(set...)
+  set();
+  set( const set& );
+
+  bool empty() const;
+  size_type size() const;
+  void clear();
+
+  void swap(set& v);
+
+
+  size_type erase(const key_type& x);
+  size_type count(const key_type& x) const;
+  
+#ifdef SWIG_EXPORT_ITERATOR_METHODS
+  class iterator;
+  class reverse_iterator;
+
+  iterator begin();
+  iterator end();
+  reverse_iterator rbegin();
+  reverse_iterator rend();
+
+%extend {
+  // %extend wrapper used for differing definitions of these methods introduced in C++11
+  void erase(iterator pos) { $self->erase(pos); }
+  void erase(iterator first, iterator last) { $self->erase(first, last); }
+}
+
+  iterator find(const key_type& x);
+  iterator lower_bound(const key_type& x);
+  iterator upper_bound(const key_type& x);
+  std::pair<iterator,iterator> equal_range(const key_type& x);
+#endif
+%enddef
+
+%define %std_set_methods(set...)
+  %std_set_methods_common(set);
+#ifdef SWIG_EXPORT_ITERATOR_METHODS
+  std::pair<iterator,bool> insert(const value_type& __x);
+#endif
+%enddef
+
+// ------------------------------------------------------------------------
+// std::set
+// 
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+// 
+//   -- f(std::set<T>), f(const std::set<T>&):
+//      the parameter being read-only, either a sequence or a
+//      previously wrapped std::set<T> can be passed.
+//   -- f(std::set<T>&), f(std::set<T>*):
+//      the parameter may be modified; therefore, only a wrapped std::set
+//      can be passed.
+//   -- std::set<T> f(), const std::set<T>& f():
+//      the set is returned by copy; therefore, a sequence of T:s 
+//      is returned which is most easily used in other functions
+//   -- std::set<T>& f(), std::set<T>* f():
+//      the set is returned by reference; therefore, a wrapped std::set
+//      is returned
+//   -- const std::set<T>* f(), f(const std::set<T>*):
+//      for consistency, they expect and return a plain set pointer.
+// ------------------------------------------------------------------------
+
+%{
+#include <set>
+%}
+
+// exported classes
+
+namespace std {
+
+  template <class _Key, class _Compare = std::less< _Key >,
+	    class _Alloc = allocator< _Key > >
+  class set {
+  public:
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef _Key value_type;
+    typedef _Key key_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;
+
+    %traits_swigtype(_Key);
+
+    %fragment(SWIG_Traits_frag(std::set< _Key, _Compare, _Alloc >), "header",
+	      fragment=SWIG_Traits_frag(_Key),
+	      fragment="StdSetTraits") {
+      namespace swig {
+	template <>  struct traits<std::set< _Key, _Compare, _Alloc > > {
+	  typedef pointer_category category;
+	  static const char* type_name() {
+	    return "std::set<" #_Key "," #_Compare "," #_Alloc " >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_SET, std::set< _Key, _Compare, _Alloc >);
+
+    set( const _Compare& );
+
+#ifdef %swig_set_methods
+    // Add swig/language extra methods
+    %swig_set_methods(std::set< _Key, _Compare, _Alloc >);
+#endif
+  
+    %std_set_methods(set);
+  };
+}
diff --git a/share/swig/2.0.11/std/std_sstream.i b/share/swig/3.0.12/std/std_sstream.i
index 12bccef..12bccef 100644
--- a/share/swig/2.0.11/std/std_sstream.i
+++ b/share/swig/3.0.12/std/std_sstream.i
diff --git a/share/swig/3.0.12/std/std_stack.i b/share/swig/3.0.12/std/std_stack.i
new file mode 100644
index 0000000..5b624b5
--- /dev/null
+++ b/share/swig/3.0.12/std/std_stack.i
@@ -0,0 +1,128 @@
+/**
+ * @file   std_stack.i
+ * @date   Sun May  6 01:48:07 2007
+ * 
+ * @brief  A wrapping of std::stack for Ruby.
+ * 
+ * 
+ */
+
+%include <std_container.i>
+
+// Stack
+
+%define %std_stack_methods(stack...)
+  stack();
+  stack( const _Sequence& );
+
+  bool empty() const;
+  size_type size() const;
+  const value_type& top() const;
+  void pop();
+  void push( const value_type& );
+%enddef
+
+%define %std_stack_methods_val(stack...) 
+  %std_stack_methods(stack)
+%enddef
+
+// ------------------------------------------------------------------------
+// std::stack
+// 
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+// 
+//   -- f(std::stack<T>), f(const std::stack<T>&):
+//      the parameter being read-only, either a sequence or a
+//      previously wrapped std::stack<T> can be passed.
+//   -- f(std::stack<T>&), f(std::stack<T>*):
+//      the parameter may be modified; therefore, only a wrapped std::stack
+//      can be passed.
+//   -- std::stack<T> f(), const std::stack<T>& f():
+//      the stack is returned by copy; therefore, a sequence of T:s 
+//      is returned which is most easily used in other functions
+//   -- std::stack<T>& f(), std::stack<T>* f():
+//      the stack is returned by reference; therefore, a wrapped std::stack
+//      is returned
+//   -- const std::stack<T>* f(), f(const std::stack<T>*):
+//      for consistency, they expect and return a plain stack pointer.
+// ------------------------------------------------------------------------
+
+%{
+#include <stack>
+%}
+
+// exported classes
+
+namespace std {
+
+  template<class _Tp, class _Sequence = std::deque< _Tp > >
+  class stack {
+  public:
+    typedef size_t size_type;
+    typedef _Tp value_type;
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
+    typedef _Sequence container_type;
+
+    %traits_swigtype(_Tp);
+
+    %fragment(SWIG_Traits_frag(std::stack< _Tp, _Sequence >), "header",
+	      fragment=SWIG_Traits_frag(_Tp),
+	      fragment="StdStackTraits") {
+      namespace swig {
+	template <>  struct traits<std::stack< _Tp, _Sequence > > {
+	  typedef pointer_category category;
+	  static const char* type_name() {
+	    return "std::stack<" #_Tp "," #_Sequence " >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_STACK, std::stack< _Tp, _Sequence >);
+  
+#ifdef %swig_stack_methods
+    // Add swig/language extra methods
+    %swig_stack_methods(std::stack< _Tp, _Sequence >);
+#endif
+
+    %std_stack_methods(stack);
+  };
+
+  template<class _Tp, class _Sequence > 
+  class stack< _Tp*, _Sequence > {
+  public:
+    typedef size_t size_type;
+    typedef _Sequence::value_type value_type;
+    typedef value_type reference;
+    typedef value_type const_reference;
+    typedef _Sequence container_type;
+
+    %traits_swigtype(_Tp);
+
+    %fragment(SWIG_Traits_frag(std::stack< _Tp*, _Sequence >), "header",
+	      fragment=SWIG_Traits_frag(_Tp),
+	      fragment="StdStackTraits") {
+      namespace swig {
+	template <>  struct traits<std::stack< _Tp*, _Sequence > > {
+	  typedef value_category category;
+	  static const char* type_name() {
+	    return "std::stack<" #_Tp "," #_Sequence " * >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_STACK, std::stack< _Tp*, _Sequence >);
+
+#ifdef %swig_stack_methods_val
+    // Add swig/language extra methods
+    %swig_stack_methods_val(std::stack< _Tp*, _Sequence >);
+#endif
+
+    %std_stack_methods_val(stack);
+  };
+
+}
+
diff --git a/share/swig/2.0.11/std/std_streambuf.i b/share/swig/3.0.12/std/std_streambuf.i
index 7efb19c..7efb19c 100644
--- a/share/swig/2.0.11/std/std_streambuf.i
+++ b/share/swig/3.0.12/std/std_streambuf.i
diff --git a/share/swig/2.0.11/std/std_string.i b/share/swig/3.0.12/std/std_string.i
index 35fcdd1..35fcdd1 100644
--- a/share/swig/2.0.11/std/std_string.i
+++ b/share/swig/3.0.12/std/std_string.i
diff --git a/share/swig/3.0.12/std/std_unordered_map.i b/share/swig/3.0.12/std/std_unordered_map.i
new file mode 100644
index 0000000..1cb7148
--- /dev/null
+++ b/share/swig/3.0.12/std/std_unordered_map.i
@@ -0,0 +1,129 @@
+//
+// std::unordered_map
+// Work in progress - the code is not compilable yet:
+// operator--() and constructor(compare function) not available for unordered_
+// types
+//
+
+%include <std_pair.i>
+%include <std_container.i>
+
+%define %std_unordered_map_methods_common(unordered_map...)
+  %std_container_methods(unordered_map);
+
+  size_type erase(const key_type& x);
+  size_type count(const key_type& x) const;
+
+#ifdef SWIG_EXPORT_ITERATOR_METHODS
+%extend {
+  // %extend wrapper used for differing definitions of these methods introduced in C++11
+  void erase(iterator position) { $self->erase(position); }
+  void erase(iterator first, iterator last) { $self->erase(first, last); }
+}
+
+  iterator find(const key_type& x);
+  iterator lower_bound(const key_type& x);
+  iterator upper_bound(const key_type& x);
+#endif
+%enddef
+
+%define %std_unordered_map_methods(unordered_map...)
+  %std_unordered_map_methods_common(unordered_map);
+
+  #ifdef SWIG_EXPORT_ITERATOR_METHODS
+//  iterator insert(const value_type& x);
+  #endif
+%enddef
+
+
+// ------------------------------------------------------------------------
+// std::unordered_map
+// 
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+// 
+//   -- f(std::unordered_map<T>), f(const std::unordered_map<T>&):
+//      the parameter being read-only, either a sequence or a
+//      previously wrapped std::unordered_map<T> can be passed.
+//   -- f(std::unordered_map<T>&), f(std::unordered_map<T>*):
+//      the parameter may be modified; therefore, only a wrapped std::unordered_map
+//      can be passed.
+//   -- std::unordered_map<T> f(), const std::unordered_map<T>& f():
+//      the unordered_map is returned by copy; therefore, a sequence of T:s 
+//      is returned which is most easily used in other functions
+//   -- std::unordered_map<T>& f(), std::unordered_map<T>* f():
+//      the unordered_map is returned by reference; therefore, a wrapped std::unordered_map
+//      is returned
+//   -- const std::unordered_map<T>* f(), f(const std::unordered_map<T>*):
+//      for consistency, they expect and return a plain unordered_map pointer.
+// ------------------------------------------------------------------------
+
+%{
+#include <unordered_map>
+%}
+%fragment("<algorithm>");
+%fragment("<stdexcept>");
+
+// exported class
+
+namespace std {
+
+  template<class _Key, class _Tp, class _Compare = std::less< _Key >,
+	   class _Alloc = allocator<std::pair< const _Key, _Tp > > >
+  class unordered_map {
+  public:
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef _Key key_type;
+    typedef _Tp mapped_type;
+    typedef std::pair< const _Key, _Tp > 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;
+
+    %traits_swigtype(_Key);
+    %traits_swigtype(_Tp);	    
+
+    %fragment(SWIG_Traits_frag(std::pair< _Key, _Tp >), "header",
+	      fragment=SWIG_Traits_frag(_Key),
+	      fragment=SWIG_Traits_frag(_Tp),
+	      fragment="StdPairTraits") {
+      namespace swig {
+	template <>  struct traits<std::pair< _Key, _Tp > > {
+	  typedef pointer_category category;
+	  static const char* type_name() {
+	    return "std::pair<" #_Key "," #_Tp " >";
+	  }
+	};
+      }
+    }
+
+    %fragment(SWIG_Traits_frag(std::unordered_map< _Key, _Tp, _Compare, _Alloc >), "header",
+	      fragment=SWIG_Traits_frag(std::pair< _Key, _Tp >),
+	      fragment="StdMapTraits") {
+      namespace swig {
+	template <>  struct traits<std::unordered_map< _Key, _Tp, _Compare, _Alloc > > {
+	  typedef pointer_category category;
+	  static const char* type_name() {
+	    return "std::unordered_map<" #_Key "," #_Tp "," #_Compare "," #_Alloc " >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_MAP, std::unordered_map< _Key, _Tp, _Compare, _Alloc >);
+
+    unordered_map( const _Compare& );
+
+#ifdef %swig_unordered_map_methods
+    // Add swig/language extra methods
+    %swig_unordered_map_methods(std::unordered_map< _Key, _Tp, _Compare, _Alloc >);
+#endif
+  
+    %std_unordered_map_methods(unordered_map);
+  };
+
+}
diff --git a/share/swig/3.0.12/std/std_unordered_multimap.i b/share/swig/3.0.12/std/std_unordered_multimap.i
new file mode 100644
index 0000000..46b56d8
--- /dev/null
+++ b/share/swig/3.0.12/std/std_unordered_multimap.i
@@ -0,0 +1,90 @@
+//
+// std::unordered_multimap
+// Work in progress - the code is not compilable yet:
+// operator--() and constructor(compare function) not available for unordered_
+// types
+//
+
+%include <std_unordered_map.i>
+
+
+%define %std_unordered_multimap_methods(mmap...)
+  %std_map_methods_common(mmap);
+
+#ifdef SWIG_EXPORT_ITERATOR_METHODS
+  std::pair<iterator,iterator> equal_range(const key_type& x);
+  std::pair<const_iterator,const_iterator> equal_range(const key_type& x) const;
+#endif
+%enddef
+
+// ------------------------------------------------------------------------
+// std::unordered_multimap
+// 
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+// 
+//   -- f(std::unordered_multimap<T>), f(const std::unordered_multimap<T>&):
+//      the parameter being read-only, either a sequence or a
+//      previously wrapped std::unordered_multimap<T> can be passed.
+//   -- f(std::unordered_multimap<T>&), f(std::unordered_multimap<T>*):
+//      the parameter may be modified; therefore, only a wrapped std::unordered_multimap
+//      can be passed.
+//   -- std::unordered_multimap<T> f(), const std::unordered_multimap<T>& f():
+//      the map is returned by copy; therefore, a sequence of T:s 
+//      is returned which is most easily used in other functions
+//   -- std::unordered_multimap<T>& f(), std::unordered_multimap<T>* f():
+//      the map is returned by reference; therefore, a wrapped std::unordered_multimap
+//      is returned
+//   -- const std::unordered_multimap<T>* f(), f(const std::unordered_multimap<T>*):
+//      for consistency, they expect and return a plain map pointer.
+// ------------------------------------------------------------------------
+
+
+// exported class
+
+
+namespace std {
+  template<class _Key, class _Tp, class _Compare = std::less< _Key >,
+	   class _Alloc = allocator<std::pair< const _Key, _Tp > > >
+  class unordered_multimap {
+  public:
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef _Key key_type;
+    typedef _Tp mapped_type;
+    typedef std::pair< const _Key, _Tp > 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;
+
+    %traits_swigtype(_Key);
+    %traits_swigtype(_Tp);	    
+
+    %fragment(SWIG_Traits_frag(std::unordered_multimap< _Key, _Tp, _Compare, _Alloc >), "header",
+	      fragment=SWIG_Traits_frag(std::pair< _Key, _Tp >),
+	      fragment="StdMultimapTraits") {
+      namespace swig {
+	template <>  struct traits<std::unordered_multimap< _Key, _Tp, _Compare, _Alloc > > {
+	  typedef pointer_category category;
+	  static const char* type_name() {
+	    return "std::unordered_multimap<" #_Key "," #_Tp "," #_Compare "," #_Alloc " >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_MULTIMAP, std::unordered_multimap< _Key, _Tp, _Compare, _Alloc >);
+  
+    unordered_multimap( const _Compare& );
+
+#ifdef %swig_unordered_multimap_methods
+    // Add swig/language extra methods
+    %swig_unordered_multimap_methods(std::unordered_multimap< _Key, _Tp, _Compare, _Alloc >);
+#endif
+
+    %std_unordered_multimap_methods(unordered_multimap);
+  };
+}
diff --git a/share/swig/3.0.12/std/std_unordered_multiset.i b/share/swig/3.0.12/std/std_unordered_multiset.i
new file mode 100644
index 0000000..725ca2f
--- /dev/null
+++ b/share/swig/3.0.12/std/std_unordered_multiset.i
@@ -0,0 +1,86 @@
+//
+// std::unordered_multiset
+// Work in progress - the code is not compilable yet:
+// operator--() and constructor(compare function) not available for unordered_
+// types
+//
+
+%include <std_unordered_set.i>
+
+// Unordered Multiset
+
+%define %std_unordered_multiset_methods(unordered_multiset...)
+  %std_unordered_set_methods_common(unordered_multiset);
+%enddef
+
+
+// ------------------------------------------------------------------------
+// std::unordered_multiset
+// 
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+// 
+//   -- f(std::unordered_multiset<T>), f(const std::unordered_multiset<T>&):
+//      the parameter being read-only, either a sequence or a
+//      previously wrapped std::unordered_multiset<T> can be passed.
+//   -- f(std::unordered_multiset<T>&), f(std::unordered_multiset<T>*):
+//      the parameter may be modified; therefore, only a wrapped std::unordered_multiset
+//      can be passed.
+//   -- std::unordered_multiset<T> f(), const std::unordered_multiset<T>& f():
+//      the set is returned by copy; therefore, a sequence of T:s 
+//      is returned which is most easily used in other functions
+//   -- std::unordered_multiset<T>& f(), std::unordered_multiset<T>* f():
+//      the set is returned by reference; therefore, a wrapped std::unordered_multiset
+//      is returned
+//   -- const std::unordered_multiset<T>* f(), f(const std::unordered_multiset<T>*):
+//      for consistency, they expect and return a plain set pointer.
+// ------------------------------------------------------------------------
+
+
+// exported classes
+
+namespace std {
+
+  //unordered_multiset
+
+  template <class _Key, class _Compare = std::less< _Key >,
+	    class _Alloc = allocator< _Key > >
+  class unordered_multiset {
+  public:
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef _Key value_type;
+    typedef _Key key_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;
+
+    %traits_swigtype(_Key);
+
+    %fragment(SWIG_Traits_frag(std::unordered_multiset< _Key, _Compare, _Alloc >), "header",
+	      fragment=SWIG_Traits_frag(_Key),
+	      fragment="StdMultisetTraits") {
+      namespace swig {
+	template <>  struct traits<std::unordered_multiset< _Key, _Compare, _Alloc > > {
+	  typedef pointer_category category;
+	  static const char* type_name() {
+	    return "std::unordered_multiset<" #_Key "," #_Compare "," #_Alloc " >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_MULTISET, std::unordered_multiset< _Key, _Compare, _Alloc >);
+
+    unordered_multiset( const _Compare& );
+
+#ifdef %swig_unordered_multiset_methods
+    // Add swig/language extra methods
+    %swig_unordered_multiset_methods(std::unordered_multiset< _Key, _Compare, _Alloc >);
+#endif
+  
+    %std_unordered_multiset_methods(unordered_multiset);
+  };
+}
diff --git a/share/swig/3.0.12/std/std_unordered_set.i b/share/swig/3.0.12/std/std_unordered_set.i
new file mode 100644
index 0000000..98e7920
--- /dev/null
+++ b/share/swig/3.0.12/std/std_unordered_set.i
@@ -0,0 +1,122 @@
+//
+// std::unordered_set
+// Work in progress - the code is not compilable yet:
+// operator--() and constructor(compare function) not available for unordered_
+// types
+//
+
+%include <std_container.i>
+%include <std_pair.i>
+
+// Unordered Set
+%define %std_unordered_set_methods_common(unordered_set...)
+  unordered_set();
+  unordered_set( const unordered_set& );
+
+  bool empty() const;
+  size_type size() const;
+  void clear();
+
+  void swap(unordered_set& v);
+
+
+  size_type erase(const key_type& x);
+  size_type count(const key_type& x) const;
+  
+#ifdef SWIG_EXPORT_ITERATOR_METHODS
+  class iterator;
+
+  iterator begin();
+  iterator end();
+
+%extend {
+  // %extend wrapper used for differing definitions of these methods introduced in C++11
+  void erase(iterator pos) { $self->erase(pos); }
+  void erase(iterator first, iterator last) { $self->erase(first, last); }
+}
+
+  iterator find(const key_type& x);
+  std::pair<iterator,iterator> equal_range(const key_type& x);
+#endif
+%enddef
+
+%define %std_unordered_set_methods(unordered_set...)
+  %std_unordered_set_methods_common(unordered_set);
+#ifdef SWIG_EXPORT_ITERATOR_METHODS
+  std::pair<iterator,bool> insert(const value_type& __x);
+#endif
+%enddef
+
+// ------------------------------------------------------------------------
+// std::unordered_set
+// 
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+// 
+//   -- f(std::unordered_set<T>), f(const std::unordered_set<T>&):
+//      the parameter being read-only, either a sequence or a
+//      previously wrapped std::unordered_set<T> can be passed.
+//   -- f(std::unordered_set<T>&), f(std::unordered_set<T>*):
+//      the parameter may be modified; therefore, only a wrapped std::unordered_set
+//      can be passed.
+//   -- std::unordered_set<T> f(), const std::unordered_set<T>& f():
+//      the unordered_set is returned by copy; therefore, a sequence of T:s 
+//      is returned which is most easily used in other functions
+//   -- std::unordered_set<T>& f(), std::unordered_set<T>* f():
+//      the unordered_set is returned by reference; therefore, a wrapped std::unordered_set
+//      is returned
+//   -- const std::unordered_set<T>* f(), f(const std::unordered_set<T>*):
+//      for consistency, they expect and return a plain unordered_set pointer.
+// ------------------------------------------------------------------------
+
+%{
+#include <unordered_set>
+%}
+
+// exported classes
+
+namespace std {
+
+  template <class _Key, class _Hash = std::hash< _Key >,
+            class _Compare = std::equal_to< _Key >,
+	    class _Alloc = allocator< _Key > >
+  class unordered_set {
+  public:
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef _Hash hasher;
+    typedef _Key value_type;
+    typedef _Key key_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;
+
+    %traits_swigtype(_Key);
+
+    %fragment(SWIG_Traits_frag(std::unordered_set< _Key, _Hash, _Compare, _Alloc >), "header",
+	      fragment=SWIG_Traits_frag(_Key),
+	      fragment="StdUnorderedSetTraits") {
+      namespace swig {
+	template <>  struct traits<std::unordered_set< _Key, _Hash, _Compare, _Alloc > > {
+	  typedef pointer_category category;
+	  static const char* type_name() {
+	    return "std::unordered_set<" #_Key "," #_Hash "," #_Compare "," #_Alloc " >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_SET, std::unordered_set< _Key, _Hash, _Compare, _Alloc >);
+
+    unordered_set( const _Compare& );
+
+#ifdef %swig_unordered_set_methods
+    // Add swig/language extra methods
+    %swig_unordered_set_methods(std::unordered_set< _Key, _Hash, _Compare, _Alloc >);
+#endif
+  
+    %std_unordered_set_methods(unordered_set);
+  };
+}
diff --git a/share/swig/3.0.12/std/std_vector.i b/share/swig/3.0.12/std/std_vector.i
new file mode 100644
index 0000000..fae759a
--- /dev/null
+++ b/share/swig/3.0.12/std/std_vector.i
@@ -0,0 +1,225 @@
+//
+// std::vector
+//
+
+%include <std_container.i>
+
+// Vector
+
+%define %std_vector_methods(vector...)
+  %std_sequence_methods(vector)
+  
+  void reserve(size_type n);
+  size_type capacity() const;
+%enddef
+
+
+%define %std_vector_methods_val(vector...)
+  %std_sequence_methods_val(vector)
+  
+  void reserve(size_type n);
+  size_type capacity() const;
+%enddef
+
+
+// ------------------------------------------------------------------------
+// std::vector
+// 
+// The aim of all that follows would be to integrate std::vector with 
+// as much as possible, namely, to allow the user to pass and 
+// be returned tuples or lists.
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+// 
+//   -- f(std::vector<T>), f(const std::vector<T>&):
+//      the parameter being read-only, either a sequence or a
+//      previously wrapped std::vector<T> can be passed.
+//   -- f(std::vector<T>&), f(std::vector<T>*):
+//      the parameter may be modified; therefore, only a wrapped std::vector
+//      can be passed.
+//   -- std::vector<T> f(), const std::vector<T>& f():
+//      the vector is returned by copy; therefore, a sequence of T:s 
+//      is returned which is most easily used in other functions
+//   -- std::vector<T>& f(), std::vector<T>* f():
+//      the vector is returned by reference; therefore, a wrapped std::vector
+//      is returned
+//   -- const std::vector<T>* f(), f(const std::vector<T>*):
+//      for consistency, they expect and return a plain vector pointer.
+// ------------------------------------------------------------------------
+
+%{
+#include <vector>
+%}    
+
+// exported classes
+
+
+namespace std {
+
+  template<class _Tp, class _Alloc = allocator< _Tp > >
+  class vector {
+  public:
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef _Tp value_type;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef _Tp& reference;
+    typedef const _Tp& const_reference;
+    typedef _Alloc allocator_type;
+
+    %traits_swigtype(_Tp);
+    %traits_enum(_Tp);
+
+    %fragment(SWIG_Traits_frag(std::vector< _Tp, _Alloc >), "header",
+	      fragment=SWIG_Traits_frag(_Tp),
+	      fragment="StdVectorTraits") {
+      namespace swig {
+	template <>  struct traits<std::vector< _Tp, _Alloc > > {
+	  typedef pointer_category category;
+	  static const char* type_name() {
+	    return "std::vector<" #_Tp "," #_Alloc " >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector< _Tp, _Alloc >);
+
+#ifdef %swig_vector_methods
+    // Add swig/language extra methods
+    %swig_vector_methods(std::vector< _Tp, _Alloc >);
+#endif
+  
+    %std_vector_methods(vector);
+  };
+
+  // ***
+  // This specialization should disappear or get simplified when
+  // a 'const SWIGTYPE*&' can be defined
+  // ***
+  template<class _Tp, class _Alloc >
+  class vector< _Tp*, _Alloc > {
+  public:
+    typedef size_t size_type;    
+    typedef ptrdiff_t difference_type;
+    typedef _Tp* value_type;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef value_type reference;
+    typedef value_type const_reference;
+    typedef _Alloc allocator_type;
+
+    %traits_swigtype(_Tp);
+
+    %fragment(SWIG_Traits_frag(std::vector< _Tp*, _Alloc >), "header",
+	      fragment=SWIG_Traits_frag(_Tp),
+	      fragment="StdVectorTraits") {
+      namespace swig {
+	template <>  struct traits<std::vector< _Tp*, _Alloc > > {
+	  typedef value_category category;
+	  static const char* type_name() {
+	    return "std::vector<" #_Tp " *," #_Alloc " >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector< _Tp*, _Alloc >);
+
+#ifdef %swig_vector_methods_val
+    // Add swig/language extra methods
+    %swig_vector_methods_val(std::vector< _Tp*, _Alloc >);
+#endif
+
+    %std_vector_methods_val(vector);
+  };
+
+  // ***
+  // const pointer specialization
+  // ***
+  template<class _Tp, class _Alloc >
+  class vector< _Tp const *, _Alloc > {
+  public:
+    typedef size_t size_type;    
+    typedef ptrdiff_t difference_type;
+    typedef _Tp const * value_type;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef value_type reference;
+    typedef value_type const_reference;
+    typedef _Alloc allocator_type;
+
+    %traits_swigtype(_Tp);
+
+    %fragment(SWIG_Traits_frag(std::vector< _Tp const*, _Alloc >), "header",
+	      fragment=SWIG_Traits_frag(_Tp),
+	      fragment="StdVectorTraits") {
+      namespace swig {
+	template <>  struct traits<std::vector< _Tp const*, _Alloc > > {
+	  typedef value_category category;
+	  static const char* type_name() {
+	    return "std::vector<" #_Tp " const*," #_Alloc " >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector< _Tp const*, _Alloc >);
+
+#ifdef %swig_vector_methods_val
+    // Add swig/language extra methods
+    %swig_vector_methods_val(std::vector< _Tp const*, _Alloc >);
+#endif
+
+    %std_vector_methods_val(vector);
+  };
+
+  // ***
+  // bool specialization
+  // ***
+
+  template<class _Alloc > 
+  class vector<bool,_Alloc > {
+  public:
+    typedef size_t size_type;    
+    typedef ptrdiff_t difference_type;
+    typedef bool value_type;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef value_type reference;
+    typedef value_type const_reference;
+    typedef _Alloc allocator_type;
+
+    %traits_swigtype(bool);
+
+    %fragment(SWIG_Traits_frag(std::vector<bool, _Alloc >), "header",
+	      fragment=SWIG_Traits_frag(bool),
+	      fragment="StdVectorTraits") {
+      namespace swig {
+	template <>  struct traits<std::vector<bool, _Alloc > > {
+	  typedef value_category category;
+	  static const char* type_name() {
+	    return "std::vector<bool, _Alloc >";
+	  }
+	};
+      }
+    }
+
+    %typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<bool, _Alloc >);
+
+
+#ifdef %swig_vector_methods_val
+    // Add swig/language extra methods
+    %swig_vector_methods_val(std::vector<bool, _Alloc >);
+#endif
+
+    %std_vector_methods_val(vector);
+
+#if defined(SWIG_STD_MODERN_STL) && !defined(SWIG_STD_NOMODERN_STL) 
+    void flip();
+#endif
+
+  };
+
+}
diff --git a/share/swig/2.0.11/std/std_vectora.i b/share/swig/3.0.12/std/std_vectora.i
index 0e83dc9..0e83dc9 100644
--- a/share/swig/2.0.11/std/std_vectora.i
+++ b/share/swig/3.0.12/std/std_vectora.i
diff --git a/share/swig/2.0.11/std/std_wios.i b/share/swig/3.0.12/std/std_wios.i
index e9c5dd4..e9c5dd4 100644
--- a/share/swig/2.0.11/std/std_wios.i
+++ b/share/swig/3.0.12/std/std_wios.i
diff --git a/share/swig/2.0.11/std/std_wiostream.i b/share/swig/3.0.12/std/std_wiostream.i
index b9bef90..b9bef90 100644
--- a/share/swig/2.0.11/std/std_wiostream.i
+++ b/share/swig/3.0.12/std/std_wiostream.i
diff --git a/share/swig/2.0.11/std/std_wsstream.i b/share/swig/3.0.12/std/std_wsstream.i
index 4c663fc..4c663fc 100644
--- a/share/swig/2.0.11/std/std_wsstream.i
+++ b/share/swig/3.0.12/std/std_wsstream.i
diff --git a/share/swig/2.0.11/std/std_wstreambuf.i b/share/swig/3.0.12/std/std_wstreambuf.i
index 86ac6af..86ac6af 100644
--- a/share/swig/2.0.11/std/std_wstreambuf.i
+++ b/share/swig/3.0.12/std/std_wstreambuf.i
diff --git a/share/swig/2.0.11/std/std_wstring.i b/share/swig/3.0.12/std/std_wstring.i
index e54d212..e54d212 100644
--- a/share/swig/2.0.11/std/std_wstring.i
+++ b/share/swig/3.0.12/std/std_wstring.i
diff --git a/share/swig/3.0.12/std_except.i b/share/swig/3.0.12/std_except.i
new file mode 100644
index 0000000..50b5a88
--- /dev/null
+++ b/share/swig/3.0.12/std_except.i
@@ -0,0 +1,57 @@
+/* -----------------------------------------------------------------------------
+ * std_except.i
+ *
+ * SWIG library file with typemaps to handle and throw STD exceptions in a
+ * language and STL independent way, i.e., the target language doesn't
+ * require to support STL but only the 'exception.i' mechanism.
+ *
+ * These typemaps are used when methods are declared with an STD
+ * exception specification, such as
+ *
+ *   size_t at() const throw (std::out_of_range);
+ *
+ * The typemaps here are based on the language independent
+ * 'exception.i' library. If that is working in your target language,
+ * this file will work.
+ * 
+ * If the target language doesn't implement a robust 'exception.i'
+ * mechanism, or you prefer other ways to map the STD exceptions, write
+ * a new std_except.i file in the target library directory.
+ * ----------------------------------------------------------------------------- */
+
+#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGGUILE) || defined(SWIGUTL) || defined(SWIGD)
+#error "This version of std_except.i should not be used"
+#endif
+
+%{
+#include <typeinfo>
+#include <stdexcept>
+%}
+
+%include <exception.i>
+
+
+%define %std_exception_map(Exception, Code)
+  %typemap(throws,noblock=1) Exception {
+    SWIG_exception(Code, $1.what());
+  }
+  %ignore Exception;
+  struct Exception {
+  };
+%enddef
+
+namespace std {
+  %std_exception_map(bad_cast,           SWIG_TypeError);
+  %std_exception_map(bad_exception,      SWIG_SystemError);
+  %std_exception_map(domain_error,       SWIG_ValueError);
+  %std_exception_map(exception,          SWIG_SystemError);
+  %std_exception_map(invalid_argument,   SWIG_ValueError);
+  %std_exception_map(length_error,       SWIG_IndexError);
+  %std_exception_map(logic_error,        SWIG_RuntimeError);
+  %std_exception_map(out_of_range,       SWIG_IndexError);
+  %std_exception_map(overflow_error,     SWIG_OverflowError);
+  %std_exception_map(range_error,        SWIG_OverflowError);
+  %std_exception_map(runtime_error,      SWIG_RuntimeError);
+  %std_exception_map(underflow_error,    SWIG_OverflowError);
+}
+
diff --git a/share/swig/2.0.11/stdint.i b/share/swig/3.0.12/stdint.i
index 14fe619..14fe619 100644
--- a/share/swig/2.0.11/stdint.i
+++ b/share/swig/3.0.12/stdint.i
diff --git a/share/swig/2.0.11/stl.i b/share/swig/3.0.12/stl.i
index 0b236af..0b236af 100644
--- a/share/swig/2.0.11/stl.i
+++ b/share/swig/3.0.12/stl.i
diff --git a/share/swig/3.0.12/swig.swg b/share/swig/3.0.12/swig.swg
new file mode 100644
index 0000000..6f48f0d
--- /dev/null
+++ b/share/swig/3.0.12/swig.swg
@@ -0,0 +1,699 @@
+/* -----------------------------------------------------------------------------
+ * swig.swg
+ *
+ * Common macro definitions for various SWIG directives.  This file is always 
+ * included at the top of each input file.
+ * ----------------------------------------------------------------------------- */
+
+/* -----------------------------------------------------------------------------
+ * User Directives 
+ * ----------------------------------------------------------------------------- */
+
+/* Deprecated SWIG-1.1 directives */
+
+#define %disabledoc     %warn "104:%disabledoc is deprecated"
+#define %enabledoc      %warn "105:%enabledoc is deprecated"
+#define %doconly        %warn "106:%doconly is deprecated"
+#define %style          %warn "107:%style is deprecated" /##/
+#define %localstyle     %warn "108:%localstyle is deprecated" /##/
+#define %title          %warn "109:%title is deprecated" /##/
+#define %section        %warn "110:%section is deprecated" /##/
+#define %subsection     %warn "111:%subsection is deprecated" /##/
+#define %subsubsection  %warn "112:%subsubsection is deprecated" /##/
+#define %new            %warn "117:%new is deprecated. Use %newobject"
+#define %text           %insert("null")
+
+/* Code insertion directives such as %wrapper %{ ... %} */
+
+#define %begin       %insert("begin")
+#define %runtime     %insert("runtime")
+#define %header      %insert("header")
+#define %wrapper     %insert("wrapper")
+#define %init        %insert("init")
+
+/* Class extension */
+
+#define %addmethods  %warn "113:%addmethods is now %extend" %extend
+
+/* %ignore directive */
+
+#define %ignore         %rename($ignore)
+#define %ignorewarn(x)  %rename("$ignore:" x)
+
+/* Access control directives */
+
+#define %readonly    %warn "114:%readonly is deprecated. Use %immutable; " %feature("immutable");
+#define %readwrite   %warn "115:%readwrite is deprecated. Use %mutable; " %feature("immutable","");
+
+#define %immutable       %feature("immutable")
+#define %noimmutable     %feature("immutable","0")
+#define %clearimmutable  %feature("immutable","")
+#define %mutable         %clearimmutable
+
+/* Generation of default constructors/destructors (old form, don't use) */
+#define %nodefault       %feature("nodefault","1")
+#define %default         %feature("nodefault","0")
+#define %clearnodefault  %feature("nodefault","")
+#define %makedefault     %clearnodefault
+
+/* Disable the generation of implicit default constructor */
+#define %nodefaultctor       %feature("nodefaultctor","1")
+#define %defaultctor         %feature("nodefaultctor","0")
+#define %clearnodefaultctor  %feature("nodefaultctor","")
+
+/* Disable the generation of implicit default destructor (dangerous) */
+#define %nodefaultdtor       %feature("nodefaultdtor","1")
+#define %defaultdtor         %feature("nodefaultdtor","0")
+#define %clearnodefaultdtor  %feature("nodefaultdtor","")
+
+/* Enable the generation of copy constructor */
+#define %copyctor       %feature("copyctor","1")
+#define %nocopyctor     %feature("copyctor","0")
+#define %clearcopyctor  %feature("copyctor","")
+
+/* Force the old nodefault behavior, ie disable both constructor and destructor */
+#define %oldnodefault       %feature("oldnodefault","1")
+#define %nooldnodefault     %feature("oldnodefault","0")
+#define %clearoldnodefault  %feature("oldnodefault","")
+
+/* the %exception directive */
+#if defined(SWIGCSHARP) || defined(SWIGD)
+#define %exception      %feature("except", canthrow=1)
+#else
+#define %exception      %feature("except")
+#endif
+#define %noexception    %feature("except","0")
+#define %clearexception %feature("except","")
+
+/* the %allowexception directive allows the %exception feature to
+   be applied to set/get variable methods */
+#define %allowexception      %feature("allowexcept")
+#define %noallowexception    %feature("allowexcept","0")
+#define %clearallowexception %feature("allowexcept","")
+
+/* the %exceptionvar directive, as %exception but it is only applied
+   to set/get variable methods. You don't need to use the
+   %allowexception directive when using %exceptionvar.
+*/
+#if defined(SWIGCSHARP) || defined(SWIGD)
+#define %exceptionvar      %feature("exceptvar", canthrow=1)
+#else
+#define %exceptionvar      %feature("exceptvar")
+#endif
+#define %noexceptionvar    %feature("exceptvar","0")
+#define %clearexceptionvar %feature("exceptvar","")
+
+/* the %catches directive */
+#define %catches(tlist...)    %feature("catches","("`tlist`")")
+#define %clearcatches         %feature("catches","")
+
+/* the %exceptionclass directive */
+#define %exceptionclass      %feature("exceptionclass")
+#define %noexceptionclass    %feature("exceptionclass","0")
+#define %clearexceptionclass %feature("exceptionclass","")
+
+/* the %newobject directive */
+#define %newobject        %feature("new")
+#define %nonewobject      %feature("new","0")
+#define %clearnewobject   %feature("new","")
+
+/* the %delobject directive */
+#define %delobject        %feature("del")
+#define %nodelobject      %feature("del","0")
+#define %cleardelobject   %feature("del","")
+
+/* the %refobject/%unrefobject directives */
+#define %refobject         %feature("ref")
+#define %norefobject       %feature("ref","0")
+#define %clearrefobject    %feature("ref","")
+
+#define %unrefobject       %feature("unref")
+#define %nounrefobject     %feature("unref","0")
+#define %clearunrefobject  %feature("unref","")
+
+/* Directives for callback functions (experimental) */
+#define %callback(x)    %feature("callback",`x`)
+#define %nocallback     %feature("callback","0")
+#define %clearcallback  %feature("callback","")
+
+/* the %nestedworkaround directive (deprecated) */
+#define %nestedworkaround       %feature("nestedworkaround")
+#define %nonestedworkaround     %feature("nestedworkaround","0")
+#define %clearnestedworkaround  %feature("nestedworkaround","")
+
+/* the %flatnested directive */
+#define %flatnested       %feature("flatnested")
+#define %noflatnested     %feature("flatnested","0")
+#define %clearflatnested  %feature("flatnested","")
+
+/* the %fastdispatch directive */
+#define %fastdispatch        %feature("fastdispatch")
+#define %nofastdispatch      %feature("fastdispatch","0")
+#define %clearfastdispatch   %feature("fastdispatch","")
+
+/* directors directives */
+#define %director      %feature("director")
+#define %nodirector    %feature("director","0")
+#define %cleardirector %feature("director","")
+
+/* naturalvar directives */
+#define %naturalvar      %feature("naturalvar")
+#define %nonaturalvar    %feature("naturalvar","0")
+#define %clearnaturalvar %feature("naturalvar","")
+
+/* nspace directives */
+#define %nspace      %feature("nspace")
+#define %nonspace    %feature("nspace","0")
+#define %clearnspace %feature("nspace","")
+
+/* valuewrapper directives */
+#define %valuewrapper        %feature("valuewrapper")
+#define %clearvaluewrapper   %feature("valuewrapper","")
+#define %novaluewrapper      %feature("novaluewrapper")
+#define %clearnovaluewrapper %feature("novaluewrapper","")
+
+/* Contract support - Experimental and undocumented */
+#define %contract      %feature("contract")
+#define %nocontract    %feature("contract","0")
+#define %clearcontract %feature("contract","")
+
+/* Macro for setting a dynamic cast function */
+%define DYNAMIC_CAST(mangle,func)
+%init %{
+   mangle->dcast = (swig_dycast_func) func;
+%}
+%enddef
+
+/* aggregation support */
+/*
+  This macro performs constant aggregation.  Basically the idea of
+  constant aggregation is that you can group a collection of constants
+  together.  For example, suppose you have some code like this:
+
+       #define UP  1
+       #define DOWN 2
+       #define LEFT 3
+       #define RIGHT 4
+
+  Now, suppose you had a function like this:
+
+       int move(int direction)
+
+  In this case, you might want to restrict the direction argument to
+  one of the supplied constant names. To do this, you could write some
+  typemap code by hand.  Alternatively, you can use the
+  %aggregate_check macro defined here to create a simple check
+  function for you.  Here is an example:
+
+    %aggregate_check(int, check_direction, UP, DOWN, LEFT, RIGHT);
+
+  Now, using a typemap
+
+    %typemap(check) int direction {
+      if (!check_direction($1)) SWIG_exception(SWIG_ValueError,"Bad direction.");
+    }
+
+  or a contract (better)
+
+    %contract move(int x) {
+    require:
+        check_direction(x);
+    }
+
+*/
+   
+%define %aggregate_check(TYPE, NAME, FIRST, ...)
+%wrapper %{
+static int NAME(TYPE x) {
+    static  TYPE values[] = { FIRST, ##__VA_ARGS__ };
+    static  int size = sizeof(values);
+    int     i,j;
+    for (i = 0, j = 0; i < size; i+=sizeof(TYPE),j++) {
+        if (x == values[j]) return 1; 
+    }
+    return 0;
+}
+%}
+%enddef
+
+
+/* -----------------------------------------------------------------------------
+ * %rename predicates
+ * ----------------------------------------------------------------------------- */
+/* 
+   Predicates to be used with %rename, for example:
+
+   - to rename all the functions:
+
+     %rename("%(utitle)s", %$isfunction) "";
+
+   - to rename only the member methods:
+
+     %rename("m_%(utitle)s", %$isfunction, %$ismember) "";
+
+   - to rename only the global functions:
+
+      %rename("m_%(utitle)s", %$isfunction, %$not %$ismember) "";
+
+     or
+
+      %rename("g_%(utitle)s", %$isfunction, %$isglobal) "";
+
+   - to ignore the enumitems in a given class:
+
+     %rename("$ignore", %$isenumitem, %$classname="MyClass") "";
+
+   we use the prefix '%$' to avoid clashes with other swig
+   macros/directives.
+
+*/
+
+%define %$not            "not" %enddef 
+%define %$isenum         "match"="enum"  %enddef
+%define %$isenumitem     "match"="enumitem"  %enddef
+%define %$isaccess       "match"="access"   %enddef
+%define %$isclass        "match"="class","notmatch$template$templatetype"="class"   %enddef
+%define %$isextend       "match"="extend"  %enddef
+%define %$isconstructor  "match"="constructor"  %enddef
+%define %$isdestructor   "match"="destructor"  %enddef
+%define %$isnamespace    "match"="namespace"  %enddef
+%define %$istemplate     "match"="template"  %enddef
+%define %$isconstant     "match"="constant"  %enddef  /* %constant definition */
+
+%define %$isunion        "match$kind"="union"  %enddef
+%define %$isfunction     "match$kind"="function"  %enddef
+%define %$isvariable     "match$kind"="variable"  %enddef
+%define %$isimmutable    "match$feature:immutable"="1"  %enddef
+%define %$hasconsttype   "match$hasconsttype"="1"  %enddef
+%define %$hasvalue       "match$hasvalue"="1"  %enddef
+%define %$isextension    "match$isextension"="1"  %enddef
+
+%define %$isstatic       "match$storage"="static"  %enddef
+%define %$isfriend       "match$storage"="friend"  %enddef
+%define %$istypedef      "match$storage"="typedef"  %enddef
+%define %$isvirtual      "match$storage"="virtual"  %enddef
+%define %$isexplicit     "match$storage"="explicit"  %enddef
+%define %$isextern       "match$storage"="extern"  %enddef
+
+%define %$ismember       "match$ismember"="1"  %enddef
+%define %$isglobal       %$not %$ismember  %enddef
+%define %$isextendmember "match$isextendmember"="1"  %enddef
+%define %$innamespace    "match$parentNode$nodeType"="namespace"  %enddef
+
+%define %$ispublic       "match$access"="public"  %enddef
+%define %$isprotected    "match$access"="protected"  %enddef
+%define %$isprivate      "match$access"="private"  %enddef
+
+%define %$ismemberget    "match$memberget"="1"  %enddef
+%define %$ismemberset    "match$memberset"="1"  %enddef
+
+%define %$classname      %$ismember,"match$parentNode$name"  %enddef
+%define %$isnested       "match$nested"="1"  %enddef
+/* -----------------------------------------------------------------------------
+ * Include all the warnings labels and macros 
+ * ----------------------------------------------------------------------------- */
+
+%include <swigwarnings.swg>
+
+/* -----------------------------------------------------------------------------
+ * Overloading support
+ * ----------------------------------------------------------------------------- */
+
+/*
+ * Function/method overloading support.   This is done through typemaps,
+ * but also involves a precedence level.
+ */
+
+/* Macro for overload resolution */
+
+%define %typecheck(_x...) %typemap(typecheck, precedence=_x) %enddef
+
+/* Macros for precedence levels */
+
+%define SWIG_TYPECHECK_POINTER       0     %enddef
+%define SWIG_TYPECHECK_ITERATOR      5     %enddef
+%define SWIG_TYPECHECK_VOIDPTR       10    %enddef
+%define SWIG_TYPECHECK_BOOL          15    %enddef
+%define SWIG_TYPECHECK_UINT8         20    %enddef
+%define SWIG_TYPECHECK_INT8          25    %enddef
+%define SWIG_TYPECHECK_UINT16        30    %enddef
+%define SWIG_TYPECHECK_INT16         35    %enddef
+%define SWIG_TYPECHECK_UINT32        40    %enddef
+%define SWIG_TYPECHECK_INT32         45    %enddef
+%define SWIG_TYPECHECK_SIZE          47    %enddef
+%define SWIG_TYPECHECK_PTRDIFF       48    %enddef
+%define SWIG_TYPECHECK_UINT64        50    %enddef
+%define SWIG_TYPECHECK_INT64         55    %enddef
+%define SWIG_TYPECHECK_UINT128       60    %enddef
+%define SWIG_TYPECHECK_INT128        65    %enddef
+%define SWIG_TYPECHECK_INTEGER       70    %enddef
+%define SWIG_TYPECHECK_FLOAT         80    %enddef
+%define SWIG_TYPECHECK_DOUBLE        90    %enddef
+%define SWIG_TYPECHECK_CPLXFLT       95    %enddef
+%define SWIG_TYPECHECK_CPLXDBL      100    %enddef
+%define SWIG_TYPECHECK_COMPLEX      105    %enddef
+%define SWIG_TYPECHECK_UNICHAR      110    %enddef
+%define SWIG_TYPECHECK_STDUNISTRING 115    %enddef
+%define SWIG_TYPECHECK_UNISTRING    120    %enddef
+%define SWIG_TYPECHECK_CHAR         130    %enddef
+%define SWIG_TYPECHECK_STDSTRING    135    %enddef
+%define SWIG_TYPECHECK_STRING       140    %enddef
+%define SWIG_TYPECHECK_PAIR         150    %enddef
+%define SWIG_TYPECHECK_STDARRAY     155    %enddef
+%define SWIG_TYPECHECK_VECTOR       160    %enddef
+%define SWIG_TYPECHECK_DEQUE        170    %enddef
+%define SWIG_TYPECHECK_LIST         180    %enddef
+%define SWIG_TYPECHECK_SET          190    %enddef
+%define SWIG_TYPECHECK_MULTISET     200    %enddef
+%define SWIG_TYPECHECK_MAP          210    %enddef
+%define SWIG_TYPECHECK_MULTIMAP     220    %enddef
+%define SWIG_TYPECHECK_STACK        230    %enddef
+%define SWIG_TYPECHECK_QUEUE        240    %enddef
+
+%define SWIG_TYPECHECK_BOOL_ARRAY        1015    %enddef
+%define SWIG_TYPECHECK_INT8_ARRAY        1025    %enddef
+%define SWIG_TYPECHECK_INT16_ARRAY       1035    %enddef
+%define SWIG_TYPECHECK_INT32_ARRAY       1045    %enddef
+%define SWIG_TYPECHECK_INT64_ARRAY       1055    %enddef
+%define SWIG_TYPECHECK_INT128_ARRAY      1065    %enddef
+%define SWIG_TYPECHECK_FLOAT_ARRAY       1080    %enddef
+%define SWIG_TYPECHECK_DOUBLE_ARRAY      1090    %enddef
+%define SWIG_TYPECHECK_CHAR_ARRAY        1130    %enddef
+%define SWIG_TYPECHECK_STRING_ARRAY      1140    %enddef
+%define SWIG_TYPECHECK_OBJECT_ARRAY      1150    %enddef
+
+%define SWIG_TYPECHECK_BOOL_PTR          2015    %enddef
+%define SWIG_TYPECHECK_UINT8_PTR         2020    %enddef
+%define SWIG_TYPECHECK_INT8_PTR          2025    %enddef
+%define SWIG_TYPECHECK_UINT16_PTR        2030    %enddef
+%define SWIG_TYPECHECK_INT16_PTR         2035    %enddef
+%define SWIG_TYPECHECK_UINT32_PTR        2040    %enddef
+%define SWIG_TYPECHECK_INT32_PTR         2045    %enddef
+%define SWIG_TYPECHECK_UINT64_PTR        2050    %enddef
+%define SWIG_TYPECHECK_INT64_PTR         2055    %enddef
+%define SWIG_TYPECHECK_FLOAT_PTR         2080    %enddef
+%define SWIG_TYPECHECK_DOUBLE_PTR        2090    %enddef
+%define SWIG_TYPECHECK_CHAR_PTR          2130    %enddef
+
+%define SWIG_TYPECHECK_SWIGOBJECT        5000    %enddef
+
+
+/* -----------------------------------------------------------------------------
+ * Default handling of certain overloaded operators 
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+%ignoreoperator(NEW)     operator new;
+%ignoreoperator(DELETE)  operator delete;
+%ignoreoperator(NEWARR)  operator new[];
+%ignoreoperator(DELARR)  operator delete[];
+
+/* add C++ operator aliases */
+%rename("operator &&") operator and;    // `and'    `&&'
+%rename("operator ||") operator or;     // `or'     `||'
+%rename("operator !")  operator not;    // `not'     `!'
+%rename("operator &=") operator and_eq; // `and_eq'  `&='
+%rename("operator &")  operator bitand; // `bitand'  `&'
+%rename("operator |")  operator bitor;  // `bitor'   `|'
+%rename("operator ~")  operator compl;  // `compl'   `~'
+%rename("operator !=") operator not_eq; // `not_eq'  `!='
+%rename("operator |=") operator or_eq;  // `or_eq'   `|='
+%rename("operator ^")  operator xor;    // `xor'     `^'
+%rename("operator ^=") operator xor_eq; // `xor_eq'  `^='
+
+/* Smart pointer handling */
+
+%rename(__deref__) *::operator->;
+%rename(__ref__)   *::operator*();
+%rename(__ref__)   *::operator*() const;
+
+/* Define std namespace */
+namespace std {
+  /* Warn about std::initializer_list usage. The constructor/method where used should probably be ignored. See docs. */
+  template<typename T> class initializer_list {};
+  %typemap(in, warning=SWIGWARN_TYPEMAP_INITIALIZER_LIST_MSG) initializer_list<T> ""
+  %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) initializer_list<T> ""
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Default char * and C array typemaps
+ * ----------------------------------------------------------------------------- */
+
+/* Set up the typemap for handling new return strings */
+
+#ifdef __cplusplus
+%typemap(newfree) char * "delete [] $1;";
+#else
+%typemap(newfree) char * "free($1);";
+#endif
+
+/* Default typemap for handling char * members */
+
+#ifdef __cplusplus
+%typemap(memberin) char * {
+  delete [] $1;
+  if ($input) {
+     $1 = ($1_type) (new char[strlen((const char *)$input)+1]);
+     strcpy((char *)$1, (const char *)$input);
+  } else {
+     $1 = 0;
+  }
+}
+%typemap(memberin,warning=SWIGWARN_TYPEMAP_CHARLEAK_MSG) const char * {
+  if ($input) {
+     $1 = ($1_type) (new char[strlen((const char *)$input)+1]);
+     strcpy((char *)$1, (const char *)$input);
+  } else {
+     $1 = 0;
+  }
+}
+%typemap(globalin) char * {
+  delete [] $1;
+  if ($input) {
+     $1 = ($1_type) (new char[strlen((const char *)$input)+1]);
+     strcpy((char *)$1, (const char *)$input);
+  } else {
+     $1 = 0;
+  }
+}
+%typemap(globalin,warning=SWIGWARN_TYPEMAP_CHARLEAK_MSG) const char * {
+  if ($input) {
+     $1 = ($1_type) (new char[strlen((const char *)$input)+1]);
+     strcpy((char *)$1, (const char *)$input);
+  } else {
+     $1 = 0;
+  }
+}
+#else
+%typemap(memberin) char * {
+  free($1);
+  if ($input) {
+     $1 = ($1_type) malloc(strlen((const char *)$input)+1);
+     strcpy((char *)$1, (const char *)$input);
+  } else {
+     $1 = 0;
+  }
+}
+%typemap(memberin,warning=SWIGWARN_TYPEMAP_CHARLEAK_MSG) const char * {
+  if ($input) {
+     $1 = ($1_type) malloc(strlen((const char *)$input)+1);
+     strcpy((char *)$1, (const char *)$input);
+  } else {
+     $1 = 0;
+  }
+}
+%typemap(globalin) char * {
+  free($1);
+  if ($input) {
+     $1 = ($1_type) malloc(strlen((const char *)$input)+1);
+     strcpy((char *)$1, (const char *)$input);
+  } else {
+     $1 = 0;
+  }
+}
+%typemap(globalin,warning=SWIGWARN_TYPEMAP_CHARLEAK_MSG) const char * {
+  if ($input) {
+     $1 = ($1_type) malloc(strlen((const char *)$input)+1);
+     strcpy((char *)$1, (const char *)$input);
+  } else {
+     $1 = 0;
+  }
+}
+
+#endif
+
+/* Character array handling */
+
+%typemap(memberin) char [ANY] {
+  if($input) {
+    strncpy((char*)$1, (const char *)$input, $1_dim0-1);
+    $1[$1_dim0-1] = 0;
+  } else {
+    $1[0] = 0;
+  }
+}
+
+%typemap(globalin) char [ANY] {
+  if($input) {
+    strncpy((char*)$1, (const char *)$input, $1_dim0-1);
+    $1[$1_dim0-1] = 0;
+  } else {
+    $1[0] = 0;
+  }
+}
+
+%typemap(memberin) char [] {
+  if ($input) strcpy((char *)$1, (const char *)$input);
+  else $1[0] = 0;
+}
+
+%typemap(globalin) char [] {
+  if ($input) strcpy((char *)$1, (const char *)$input);
+  else $1[0] = 0;
+}
+
+/* memberin/globalin typemap for arrays. */
+
+%typemap(memberin) SWIGTYPE [ANY] {
+  size_t ii;
+  $1_basetype *b = ($1_basetype *) $1;
+  for (ii = 0; ii < (size_t)$1_size; ii++) b[ii] = *(($1_basetype *) $input + ii);
+}
+
+%typemap(globalin) SWIGTYPE [ANY] {
+  size_t ii;
+  $1_basetype *b = ($1_basetype *) $1;
+  for (ii = 0; ii < (size_t)$1_size; ii++) b[ii] = *(($1_basetype *) $input + ii);
+}
+
+/* memberin/globalin typemap for double arrays. */
+
+%typemap(memberin) SWIGTYPE [ANY][ANY] {
+  $basetype (*inp)[$1_dim1] = ($basetype (*)[$1_dim1])($input);
+  $basetype (*dest)[$1_dim1] = ($basetype (*)[$1_dim1])($1);
+  size_t ii = 0;
+  for (; ii < $1_dim0; ++ii) {
+    $basetype *ip = inp[ii];
+    $basetype *dp = dest[ii];
+    size_t jj = 0;
+    for (; jj < $1_dim1; ++jj) dp[jj] = ip[jj];
+  }
+}
+
+%typemap(globalin) SWIGTYPE [ANY][ANY] {
+  $basetype (*inp)[$1_dim1] = ($basetype (*)[$1_dim1])($input);
+  $basetype (*dest)[$1_dim1] = ($basetype (*)[$1_dim1])($1);
+  size_t ii = 0;
+  for (; ii < $1_dim0; ++ii) {
+    $basetype *ip = inp[ii];
+    $basetype *dp = dest[ii];
+    size_t jj = 0;
+    for (; jj < $1_dim1; ++jj) dp[jj] = ip[jj];
+  }
+}
+
+/* -----------------------------------------------------------------------------
+ *  Runtime code
+ * ----------------------------------------------------------------------------- */
+
+/*  The SwigValueWrapper class  */
+
+/*  
+ * This template wrapper is used to handle C++ objects that are passed or 
+ * returned by value.   This is necessary to handle objects that define
+ * no default-constructor (making it difficult for SWIG to properly declare
+ * local variables).
+ *
+ * The wrapper is used as follows.  First consider a function like this:
+ *
+ *      Vector cross_product(Vector a, Vector b)
+ *
+ * Now, if Vector is defined as a C++ class with no default constructor, 
+ * code is generated as follows:
+ *
+ *     Vector *wrap_cross_product(Vector *inarg1, Vector *inarg2) {
+ *          SwigValueWrapper<Vector>  arg1;
+ *          SwigValueWrapper<Vector>  arg2;
+ *          SwigValueWrapper<Vector> result;
+ *
+ *          arg1 = *inarg1;
+ *          arg2 = *inarg2;
+ *          ...            
+ *          result = cross_product(arg1,arg2);
+ *          ...
+ *          return new Vector(result);
+ *    }
+ *         
+ * In the wrappers, the template SwigValueWrapper simply provides a thin
+ * layer around a Vector *.  However, it does this in a way that allows
+ * the object to be bound after the variable declaration (which is not possible
+ * with the bare object when it lacks a default constructor).  
+ *
+ * An observant reader will notice that the code after the variable declarations
+ * is *identical* to the code used for classes that do define default constructors.
+ * Thus, this neat trick allows us to fix this special case without having to
+ * make massive changes to typemaps and other parts of the SWIG code generator.
+ *
+ * Note: this code is not included when SWIG runs in C-mode, when classes
+ * define default constructors, or when pointers and references are used.
+ * SWIG tries to avoid doing this except in very special circumstances.
+ *
+ * Note: This solution suffers from making a large number of copies
+ * of the underlying object.  However, this is needed in the interest of
+ * safety and in order to cover all of the possible ways in which a value
+ * might be assigned.  For example:
+ *
+ *       arg1 = *inarg1;       // Assignment from a pointer
+ *       arg1 = Vector(1,2,3); // Assignment from a value  
+ *
+ * The class offers a strong guarantee of exception safety.
+ * With regards to the implementation, the private SwigMovePointer nested class is 
+ * a simple smart pointer with move semantics, much like std::auto_ptr.
+ *
+ * This wrapping technique was suggested by William Fulton and is henceforth
+ * known as the "Fulton Transform" :-).
+ */
+
+#ifdef __cplusplus
+%insert("runtime") %{
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
+};%}
+
+/*
+ * SwigValueInit() is a generic initialisation solution as the following approach:
+ * 
+ *       T c_result = T();
+ * 
+ * doesn't compile for all types for example:
+ * 
+ *       unsigned int c_result = unsigned int();
+ */
+%insert("runtime") %{
+template <typename T> T SwigValueInit() {
+  return T();
+}
+#endif
+%}
+#endif
+
+/*  The swiglabels  */
+
+%insert("runtime") "swiglabels.swg"
+
+
diff --git a/share/swig/3.0.12/swigarch.i b/share/swig/3.0.12/swigarch.i
new file mode 100644
index 0000000..bf4ee8e
--- /dev/null
+++ b/share/swig/3.0.12/swigarch.i
@@ -0,0 +1,62 @@
+/* -----------------------------------------------------------------------------
+ * swigarch.i
+ *
+ * SWIG library file for 32bit/64bit code specialization and checking.
+ *
+ * Use only in extreme cases, when no arch. independent code can be
+ * generated
+ * 
+ * To activate architecture specific code, use
+ *
+ *     swig -DSWIGWORDSIZE32
+ *
+ * or
+ *
+ *     swig -DSWIGWORDSIZE64
+ *
+ * Note that extra checking code will be added to the wrapped code,
+ * which will prevent the compilation in a different architecture.
+ *
+ * If you don't specify the SWIGWORDSIZE (the default case), swig will
+ * generate architecture independent and/or 32bits code, with no extra
+ * checking code added.
+ * ----------------------------------------------------------------------------- */
+
+#if !defined(SWIGWORDSIZE32) &&  !defined(SWIGWORDSIZE64)
+# if (__WORDSIZE == 32)
+#  define SWIGWORDSIZE32
+# endif
+#endif
+  
+#if !defined(SWIGWORDSIZE64) &&  !defined(SWIGWORDSIZE32) 
+# if defined(__x86_64) || defined(__x86_64__) || (__WORDSIZE == 64)
+#  define SWIGWORDSIZE64
+# endif
+#endif
+
+
+#ifdef SWIGWORDSIZE32
+%{
+#define SWIGWORDSIZE32
+#ifndef LONG_MAX
+#include <limits.h>
+#endif
+#if (__WORDSIZE == 64) || (LONG_MAX != INT_MAX)
+# error "SWIG wrapped code invalid in 64 bit architecture, regenerate code using -DSWIGWORDSIZE64"
+#endif
+%}
+#endif
+
+#ifdef SWIGWORDSIZE64
+%{
+#define SWIGWORDSIZE64
+#ifndef LONG_MAX
+#include <limits.h>
+#endif
+#if (__WORDSIZE == 32) || (LONG_MAX == INT_MAX)
+# error "SWIG wrapped code invalid in 32 bit architecture, regenerate code using -DSWIGWORDSIZE32"
+#endif
+%}
+#endif
+  
+
diff --git a/share/swig/2.0.11/swigerrors.swg b/share/swig/3.0.12/swigerrors.swg
index 1a6d203..1a6d203 100644
--- a/share/swig/2.0.11/swigerrors.swg
+++ b/share/swig/3.0.12/swigerrors.swg
diff --git a/share/swig/3.0.12/swiginit.swg b/share/swig/3.0.12/swiginit.swg
new file mode 100644
index 0000000..cb72c36
--- /dev/null
+++ b/share/swig/3.0.12/swiginit.swg
@@ -0,0 +1,230 @@
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned statically to an initial
+ * array. We just loop through that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded.
+ * There are three cases to handle:
+ *  1) If the cast->type has already been loaded AND the type we are adding
+ *     casting info to has not been loaded (it is in this module), THEN we
+ *     replace the cast->type pointer with the type pointer that has already
+ *     been loaded.
+ *  2) If BOTH types (the one we are adding casting info to, and the
+ *     cast->type) are loaded, THEN the cast info has already been loaded by
+ *     the previous module so we just ignore it.
+ *  3) Finally, if cast->type has not already been loaded, then we add that
+ *     swig_cast_info to the linked list (because the cast->type) pointer will
+ *     be correct.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* c-mode */
+#endif
+#endif
+
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+  size_t i;
+  swig_module_info *module_head, *iter;
+  int init;
+
+  /* check to see if the circular list has been setup, if not, set it up */
+  if (swig_module.next==0) {
+    /* Initialize the swig_module */
+    swig_module.type_initial = swig_type_initial;
+    swig_module.cast_initial = swig_cast_initial;
+    swig_module.next = &swig_module;
+    init = 1;
+  } else {
+    init = 0;
+  }
+
+  /* Try and load any already created modules */
+  module_head = SWIG_GetModule(clientdata);
+  if (!module_head) {
+    /* This is the first module loaded for this interpreter */
+    /* so set the swig module into the interpreter */
+    SWIG_SetModule(clientdata, &swig_module);
+  } else {
+    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+    iter=module_head;
+    do {
+      if (iter==&swig_module) {
+        /* Our module is already in the list, so there's nothing more to do. */
+        return;
+      }
+      iter=iter->next;
+    } while (iter!= module_head);
+
+    /* otherwise we must add our module into the list */
+    swig_module.next = module_head->next;
+    module_head->next = &swig_module;
+  }
+
+  /* When multiple interpreters are used, a module could have already been initialized in
+     a different interpreter, but not yet have a pointer in this interpreter.
+     In this case, we do not want to continue adding types... everything should be
+     set up already */
+  if (init == 0) return;
+
+  /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+  for (i = 0; i < swig_module.size; ++i) {
+    swig_type_info *type = 0;
+    swig_type_info *ret;
+    swig_cast_info *cast;
+
+#ifdef SWIGRUNTIME_DEBUG
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+
+    /* if there is another module already loaded */
+    if (swig_module.next != &swig_module) {
+      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
+    }
+    if (type) {
+      /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+      if (swig_module.type_initial[i]->clientdata) {
+	type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+      }
+    } else {
+      type = swig_module.type_initial[i];
+    }
+
+    /* Insert casting types */
+    cast = swig_module.cast_initial[i];
+    while (cast->type) {
+
+      /* Don't need to add information already in the list */
+      ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+      if (swig_module.next != &swig_module) {
+        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+      }
+      if (ret) {
+	if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+	  cast->type = ret;
+	  ret = 0;
+	} else {
+	  /* Check for casting already in the list */
+	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+	  if (!ocast) ret = 0;
+	}
+      }
+
+      if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+        if (type->cast) {
+          type->cast->prev = cast;
+          cast->next = type->cast;
+        }
+        type->cast = cast;
+      }
+      cast++;
+    }
+    /* Set entry in modules->types array equal to the type */
+    swig_module.types[i] = type;
+  }
+  swig_module.types[i] = 0;
+
+#ifdef SWIGRUNTIME_DEBUG
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+  for (i = 0; i < swig_module.size; ++i) {
+    int j = 0;
+    swig_cast_info *cast = swig_module.cast_initial[i];
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    while (cast->type) {
+      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+      cast++;
+      ++j;
+    }
+  printf("---- Total casts: %d\n",j);
+  }
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types.  It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+  size_t i;
+  swig_cast_info *equiv;
+  static int init_run = 0;
+
+  if (init_run) return;
+  init_run = 1;
+
+  for (i = 0; i < swig_module.size; i++) {
+    if (swig_module.types[i]->clientdata) {
+      equiv = swig_module.types[i]->cast;
+      while (equiv) {
+        if (!equiv->converter) {
+          if (equiv->type && !equiv->type->clientdata)
+            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+        }
+        equiv = equiv->next;
+      }
+    }
+  }
+}
+
+#ifdef __cplusplus
+#if 0
+{ /* c-mode */
+#endif
+}
+#endif
diff --git a/share/swig/3.0.12/swiglabels.swg b/share/swig/3.0.12/swiglabels.swg
new file mode 100644
index 0000000..b385566
--- /dev/null
+++ b/share/swig/3.0.12/swiglabels.swg
@@ -0,0 +1,123 @@
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
diff --git a/share/swig/2.0.11/swigrun.i b/share/swig/3.0.12/swigrun.i
index 6026a91..6026a91 100644
--- a/share/swig/2.0.11/swigrun.i
+++ b/share/swig/3.0.12/swigrun.i
diff --git a/share/swig/3.0.12/swigrun.swg b/share/swig/3.0.12/swigrun.swg
new file mode 100644
index 0000000..1ef6761
--- /dev/null
+++ b/share/swig/3.0.12/swigrun.swg
@@ -0,0 +1,572 @@
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic C API SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "4"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/*  Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN           0x1
+
+
+/*
+   Flags/methods for returning states.
+
+   The SWIG conversion methods, as ConvertPtr, return an integer
+   that tells if the conversion was successful or not. And if not,
+   an error code can be returned (see swigerrors.swg for the codes).
+
+   Use the following macros/flags to set or process the returning
+   states.
+
+   In old versions of SWIG, code such as the following was usually written:
+
+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+       // success code
+     } else {
+       //fail code
+     }
+
+   Now you can be more explicit:
+
+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+    } else {
+      // fail code
+    }
+
+   which is the same really, but now you can also do
+
+    Type *ptr;
+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+      if (SWIG_IsNewObj(res) {
+        ...
+	delete *ptr;
+      } else {
+        ...
+      }
+    } else {
+      // fail code
+    }
+
+   I.e., now SWIG_ConvertPtr can return new objects and you can
+   identify the case and take care of the deallocation. Of course that
+   also requires SWIG_ConvertPtr to return new result values, such as
+
+      int SWIG_ConvertPtr(obj, ptr,...) {
+        if (<obj is ok>) {
+          if (<need new object>) {
+            *ptr = <ptr to new allocated object>;
+            return SWIG_NEWOBJ;
+          } else {
+            *ptr = <ptr to old object>;
+            return SWIG_OLDOBJ;
+          }
+        } else {
+          return SWIG_BADOBJ;
+        }
+      }
+
+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+   SWIG errors code.
+
+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+   allows to return the 'cast rank', for example, if you have this
+
+       int food(double)
+       int fooi(int);
+
+   and you call
+
+      food(1)   // cast rank '1'  (1 -> 1.0)
+      fooi(1)   // cast rank '0'
+
+   just use the SWIG_AddCast()/SWIG_CheckState()
+*/
+
+#define SWIG_OK                    (0)
+#define SWIG_ERROR                 (-1)
+#define SWIG_IsOK(r)               (r >= 0)
+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT         (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ                (SWIG_ERROR)
+#define SWIG_OLDOBJ                (SWIG_OK)
+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+#  ifndef SWIG_TypeRank
+#    define SWIG_TypeRank             unsigned long
+#  endif
+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
+#    define SWIG_MAXCASTRANK          (2)
+#  endif
+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+#  define SWIG_AddCast(r) (r)
+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *, int *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store information on one type */
+typedef struct swig_type_info {
+  const char             *name;			/* mangled name of this type */
+  const char             *str;			/* human readable name of this type */
+  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
+  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
+  void                   *clientdata;		/* language specific type data */
+  int                    owndata;		/* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
+  swig_converter_func     converter;		/* function to cast the void pointers */
+  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
+  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
+  size_t                 size;		        /* Number of types in this module */
+  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
+  swig_type_info         **type_initial;	/* Array of initially generated type structures */
+  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
+  void                    *clientdata;		/* Language specific module data */
+} swig_module_info;
+
+/*
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+  }
+  return (int)((l1 - f1) - (l2 - f2));
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCmp(const char *nb, const char *tb) {
+  int equiv = 1;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (equiv != 0 && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
+}
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
+}
+
+/*
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+  swig_type_info *lastty = ty;
+  if (!ty || !ty->dcast) return ty;
+  while (ty && (ty->dcast)) {
+    ty = (*ty->dcast)(ptr);
+    if (ty) lastty = ty;
+  }
+  return lastty;
+}
+
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+  return ty->name;
+}
+
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (!type) return NULL;
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
+  }
+  else
+    return type->name;
+}
+
+/*
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+  swig_cast_info *cast = ti->cast;
+  /* if (ti->clientdata == clientdata) return; */
+  ti->clientdata = clientdata;
+
+  while (cast) {
+    if (!cast->converter) {
+      swig_type_info *tc = cast->type;
+      if (!tc->clientdata) {
+	SWIG_TypeClientData(tc, clientdata);
+      }
+    }
+    cast = cast->next;
+  }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientData(ti, clientdata);
+  ti->owndata = 1;
+}
+
+/*
+  Search for a swig_type_info structure only by mangled name
+  Search is a O(log #types)
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+                            swig_module_info *end,
+		            const char *name) {
+  swig_module_info *iter = start;
+  do {
+    if (iter->size) {
+      size_t l = 0;
+      size_t r = iter->size - 1;
+      do {
+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
+	size_t i = (l + r) >> 1;
+	const char *iname = iter->types[i]->name;
+	if (iname) {
+	  int compare = strcmp(name, iname);
+	  if (compare == 0) {
+	    return iter->types[i];
+	  } else if (compare < 0) {
+	    if (i) {
+	      r = i - 1;
+	    } else {
+	      break;
+	    }
+	  } else if (compare > 0) {
+	    l = i + 1;
+	  }
+	} else {
+	  break; /* should never happen */
+	}
+      } while (l <= r);
+    }
+    iter = iter->next;
+  } while (iter != end);
+  return 0;
+}
+
+/*
+  Search for a swig_type_info structure for either a mangled name or a human readable name.
+  It first searches the mangled names of the types, which is a O(log #types)
+  If a type is not found it then searches the human readable names, which is O(#types).
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+                     swig_module_info *end,
+		     const char *name) {
+  /* STEP 1: Search the name field using binary search */
+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+  if (ret) {
+    return ret;
+  } else {
+    /* STEP 2: If the type hasn't been found, do a complete search
+       of the str field (the human readable name) */
+    swig_module_info *iter = start;
+    do {
+      size_t i = 0;
+      for (; i < iter->size; ++i) {
+	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+	  return iter->types[i];
+      }
+      iter = iter->next;
+    } while (iter != end);
+  }
+
+  /* neither found a match */
+  return 0;
+}
+
+/*
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+
+/*
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = (unsigned char)((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = (unsigned char)((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (unsigned char)(d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (unsigned char)(d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/*
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/share/swig/3.0.12/swigwarn.swg b/share/swig/3.0.12/swigwarn.swg
new file mode 100644
index 0000000..1262ce0
--- /dev/null
+++ b/share/swig/3.0.12/swigwarn.swg
@@ -0,0 +1,289 @@
+/* SWIG warning codes */
+
+
+%define SWIGWARN_NONE                     0 %enddef
+
+/* -- Deprecated features -- */
+
+%define SWIGWARN_DEPRECATED_EXTERN        101 %enddef
+%define SWIGWARN_DEPRECATED_VAL           102 %enddef
+%define SWIGWARN_DEPRECATED_OUT           103 %enddef
+%define SWIGWARN_DEPRECATED_DISABLEDOC    104 %enddef
+%define SWIGWARN_DEPRECATED_ENABLEDOC     105 %enddef
+%define SWIGWARN_DEPRECATED_DOCONLY       106 %enddef
+%define SWIGWARN_DEPRECATED_STYLE         107 %enddef
+%define SWIGWARN_DEPRECATED_LOCALSTYLE    108 %enddef
+%define SWIGWARN_DEPRECATED_TITLE         109 %enddef
+%define SWIGWARN_DEPRECATED_SECTION       110 %enddef
+%define SWIGWARN_DEPRECATED_SUBSECTION    111 %enddef
+%define SWIGWARN_DEPRECATED_SUBSUBSECTION 112 %enddef
+%define SWIGWARN_DEPRECATED_ADDMETHODS    113 %enddef
+%define SWIGWARN_DEPRECATED_READONLY      114 %enddef
+%define SWIGWARN_DEPRECATED_READWRITE     115 %enddef
+%define SWIGWARN_DEPRECATED_EXCEPT        116 %enddef
+%define SWIGWARN_DEPRECATED_NEW           117 %enddef
+%define SWIGWARN_DEPRECATED_EXCEPT_TM     118 %enddef
+%define SWIGWARN_DEPRECATED_IGNORE_TM     119 %enddef
+%define SWIGWARN_DEPRECATED_OPTC          120 %enddef
+%define SWIGWARN_DEPRECATED_NAME          121 %enddef
+%define SWIGWARN_DEPRECATED_NOEXTERN      122 %enddef
+%define SWIGWARN_DEPRECATED_NODEFAULT     123 %enddef
+%define SWIGWARN_DEPRECATED_TYPEMAP_LANG  124 %enddef
+%define SWIGWARN_DEPRECATED_INPUT_FILE    125 %enddef
+%define SWIGWARN_DEPRECATED_NESTED_WORKAROUND 126 %enddef
+
+/* -- Preprocessor -- */
+
+%define SWIGWARN_PP_MISSING_FILE          201 %enddef
+%define SWIGWARN_PP_EVALUATION            202 %enddef
+%define SWIGWARN_PP_INCLUDEALL_IMPORTALL  203 %enddef
+%define SWIGWARN_PP_CPP_WARNING           204 %enddef
+%define SWIGWARN_PP_CPP_ERROR             205 %enddef
+%define SWIGWARN_PP_UNEXPECTED_TOKENS     206 %enddef
+
+/* -- C/C++ Parser -- */
+
+%define SWIGWARN_PARSE_CLASS_KEYWORD      301 %enddef
+%define SWIGWARN_PARSE_REDEFINED          302 %enddef
+%define SWIGWARN_PARSE_EXTEND_UNDEF       303 %enddef
+%define SWIGWARN_PARSE_UNSUPPORTED_VALUE  304 %enddef
+%define SWIGWARN_PARSE_BAD_VALUE          305 %enddef
+%define SWIGWARN_PARSE_PRIVATE            306 %enddef
+%define SWIGWARN_PARSE_BAD_DEFAULT        307 %enddef
+%define SWIGWARN_PARSE_NAMESPACE_ALIAS    308 %enddef
+%define SWIGWARN_PARSE_PRIVATE_INHERIT    309 %enddef
+%define SWIGWARN_PARSE_TEMPLATE_REPEAT    310 %enddef
+%define SWIGWARN_PARSE_TEMPLATE_PARTIAL   311 %enddef
+%define SWIGWARN_PARSE_UNNAMED_NESTED_CLASS 312 %enddef
+%define SWIGWARN_PARSE_UNDEFINED_EXTERN   313 %enddef
+%define SWIGWARN_PARSE_KEYWORD            314 %enddef
+%define SWIGWARN_PARSE_USING_UNDEF        315 %enddef
+%define SWIGWARN_PARSE_MODULE_REPEAT      316 %enddef
+%define SWIGWARN_PARSE_TEMPLATE_SP_UNDEF  317 %enddef
+%define SWIGWARN_PARSE_TEMPLATE_AMBIG     318 %enddef
+%define SWIGWARN_PARSE_NO_ACCESS          319 %enddef
+%define SWIGWARN_PARSE_EXPLICIT_TEMPLATE  320 %enddef
+%define SWIGWARN_PARSE_BUILTIN_NAME       321 %enddef
+%define SWIGWARN_PARSE_REDUNDANT          322 %enddef
+%define SWIGWARN_PARSE_REC_INHERITANCE    323 %enddef
+%define SWIGWARN_PARSE_NESTED_TEMPLATE    324 %enddef
+%define SWIGWARN_PARSE_NAMED_NESTED_CLASS 325 %enddef
+%define SWIGWARN_PARSE_EXTEND_NAME        326 %enddef
+
+%define SWIGWARN_CPP11_LAMBDA             340 %enddef
+%define SWIGWARN_CPP11_ALIAS_DECLARATION  341 %enddef  /* redundant now */
+%define SWIGWARN_CPP11_ALIAS_TEMPLATE     342 %enddef  /* redundant now */
+%define SWIGWARN_CPP11_VARIADIC_TEMPLATE  343 %enddef
+
+%define SWIGWARN_IGNORE_OPERATOR_NEW        350 %enddef	/* new */
+%define SWIGWARN_IGNORE_OPERATOR_DELETE     351 %enddef	/* delete */
+%define SWIGWARN_IGNORE_OPERATOR_PLUS       352 %enddef	/* + */
+%define SWIGWARN_IGNORE_OPERATOR_MINUS      353 %enddef	/* - */
+%define SWIGWARN_IGNORE_OPERATOR_MUL        354 %enddef	/* * */
+%define SWIGWARN_IGNORE_OPERATOR_DIV        355 %enddef	/* / */
+%define SWIGWARN_IGNORE_OPERATOR_MOD        356 %enddef	/* % */
+%define SWIGWARN_IGNORE_OPERATOR_XOR        357 %enddef	/* ^ */
+%define SWIGWARN_IGNORE_OPERATOR_AND        358 %enddef	/* & */
+%define SWIGWARN_IGNORE_OPERATOR_OR         359 %enddef	/* | */
+%define SWIGWARN_IGNORE_OPERATOR_NOT        360 %enddef	/* ~ */
+%define SWIGWARN_IGNORE_OPERATOR_LNOT       361 %enddef	/* ! */
+%define SWIGWARN_IGNORE_OPERATOR_EQ         362 %enddef	/* = */
+%define SWIGWARN_IGNORE_OPERATOR_LT         363 %enddef	/* < */
+%define SWIGWARN_IGNORE_OPERATOR_GT         364 %enddef	/* > */
+%define SWIGWARN_IGNORE_OPERATOR_PLUSEQ     365 %enddef	/* += */
+%define SWIGWARN_IGNORE_OPERATOR_MINUSEQ    366 %enddef	/* -= */
+%define SWIGWARN_IGNORE_OPERATOR_MULEQ      367 %enddef	/* *= */
+%define SWIGWARN_IGNORE_OPERATOR_DIVEQ      368 %enddef	/* /= */
+%define SWIGWARN_IGNORE_OPERATOR_MODEQ      369 %enddef	/* %= */
+%define SWIGWARN_IGNORE_OPERATOR_XOREQ      370 %enddef	/* ^= */
+%define SWIGWARN_IGNORE_OPERATOR_ANDEQ      371 %enddef	/* &= */
+%define SWIGWARN_IGNORE_OPERATOR_OREQ       372 %enddef	/* |= */
+%define SWIGWARN_IGNORE_OPERATOR_LSHIFT     373 %enddef	/* << */
+%define SWIGWARN_IGNORE_OPERATOR_RSHIFT     374 %enddef	/* >> */
+%define SWIGWARN_IGNORE_OPERATOR_LSHIFTEQ   375 %enddef	/* <<= */
+%define SWIGWARN_IGNORE_OPERATOR_RSHIFTEQ   376 %enddef	/* >>= */
+%define SWIGWARN_IGNORE_OPERATOR_EQUALTO    377 %enddef	/* == */
+%define SWIGWARN_IGNORE_OPERATOR_NOTEQUAL   378 %enddef	/* != */
+%define SWIGWARN_IGNORE_OPERATOR_LTEQUAL    379 %enddef	/* <= */
+%define SWIGWARN_IGNORE_OPERATOR_GTEQUAL    380 %enddef	/* >= */
+%define SWIGWARN_IGNORE_OPERATOR_LAND       381 %enddef	/* && */
+%define SWIGWARN_IGNORE_OPERATOR_LOR        382 %enddef	/* || */
+%define SWIGWARN_IGNORE_OPERATOR_PLUSPLUS   383 %enddef	/* ++ */
+%define SWIGWARN_IGNORE_OPERATOR_MINUSMINUS 384 %enddef	/* -- */
+%define SWIGWARN_IGNORE_OPERATOR_COMMA      385 %enddef	/* , */
+%define SWIGWARN_IGNORE_OPERATOR_ARROWSTAR  386 %enddef	/* ->* */
+%define SWIGWARN_IGNORE_OPERATOR_ARROW      387 %enddef	/* -> */
+%define SWIGWARN_IGNORE_OPERATOR_CALL       388 %enddef	/* () */
+%define SWIGWARN_IGNORE_OPERATOR_INDEX      389 %enddef	/* [] */
+%define SWIGWARN_IGNORE_OPERATOR_UPLUS      390 %enddef	/* + */
+%define SWIGWARN_IGNORE_OPERATOR_UMINUS     391 %enddef	/* - */
+%define SWIGWARN_IGNORE_OPERATOR_UMUL       392 %enddef	/* * */
+%define SWIGWARN_IGNORE_OPERATOR_UAND       393 %enddef	/* & */
+%define SWIGWARN_IGNORE_OPERATOR_NEWARR     394 %enddef	/* new [] */
+%define SWIGWARN_IGNORE_OPERATOR_DELARR     395 %enddef	/* delete [] */
+%define SWIGWARN_IGNORE_OPERATOR_REF        396 %enddef	/* operator *() */
+
+/* 394-399 are reserved */
+
+/* -- Type system and typemaps -- */
+
+%define SWIGWARN_TYPE_UNDEFINED_CLASS     401 %enddef
+%define SWIGWARN_TYPE_INCOMPLETE          402 %enddef
+%define SWIGWARN_TYPE_ABSTRACT            403 %enddef
+%define SWIGWARN_TYPE_REDEFINED           404 %enddef
+
+%define SWIGWARN_TYPEMAP_SOURCETARGET     450 %enddef
+%define SWIGWARN_TYPEMAP_CHARLEAK         451 %enddef
+%define SWIGWARN_TYPEMAP_SWIGTYPE         452 %enddef
+%define SWIGWARN_TYPEMAP_APPLY_UNDEF      453 %enddef
+%define SWIGWARN_TYPEMAP_SWIGTYPELEAK     454 %enddef
+
+%define SWIGWARN_TYPEMAP_IN_UNDEF         460 %enddef
+%define SWIGWARN_TYPEMAP_OUT_UNDEF        461 %enddef
+%define SWIGWARN_TYPEMAP_VARIN_UNDEF      462 %enddef
+%define SWIGWARN_TYPEMAP_VAROUT_UNDEF     463 %enddef
+%define SWIGWARN_TYPEMAP_CONST_UNDEF      464 %enddef
+%define SWIGWARN_TYPEMAP_UNDEF            465 %enddef
+%define SWIGWARN_TYPEMAP_VAR_UNDEF        466 %enddef
+%define SWIGWARN_TYPEMAP_TYPECHECK        467 %enddef
+%define SWIGWARN_TYPEMAP_THROW            468 %enddef
+%define SWIGWARN_TYPEMAP_DIRECTORIN_UNDEF  469 %enddef
+%define SWIGWARN_TYPEMAP_THREAD_UNSAFE     470 %enddef	/* mostly used in directorout typemaps */
+%define SWIGWARN_TYPEMAP_DIRECTOROUT_UNDEF 471 %enddef
+%define SWIGWARN_TYPEMAP_TYPECHECK_UNDEF   472 %enddef
+%define SWIGWARN_TYPEMAP_DIRECTOROUT_PTR   473 %enddef
+%define SWIGWARN_TYPEMAP_OUT_OPTIMAL_IGNORED  474 %enddef
+%define SWIGWARN_TYPEMAP_OUT_OPTIMAL_MULTIPLE 475 %enddef
+%define SWIGWARN_TYPEMAP_INITIALIZER_LIST  476 %enddef
+%define SWIGWARN_TYPEMAP_DIRECTORTHROWS_UNDEF 477 %enddef
+
+/* -- Fragments -- */
+%define SWIGWARN_FRAGMENT_NOT_FOUND       490 %enddef
+
+/* -- General code generation -- */
+
+%define SWIGWARN_LANG_OVERLOAD_DECL       501 %enddef
+%define SWIGWARN_LANG_OVERLOAD_CONSTRUCT  502 %enddef
+%define SWIGWARN_LANG_IDENTIFIER          503 %enddef
+%define SWIGWARN_LANG_RETURN_TYPE         504 %enddef
+%define SWIGWARN_LANG_VARARGS             505 %enddef
+%define SWIGWARN_LANG_VARARGS_KEYWORD     506 %enddef
+%define SWIGWARN_LANG_NATIVE_UNIMPL       507 %enddef
+%define SWIGWARN_LANG_DEREF_SHADOW        508 %enddef
+%define SWIGWARN_LANG_OVERLOAD_SHADOW     509 %enddef
+%define SWIGWARN_LANG_FRIEND_IGNORE       510 %enddef
+%define SWIGWARN_LANG_OVERLOAD_KEYWORD    511 %enddef
+%define SWIGWARN_LANG_OVERLOAD_CONST      512 %enddef
+%define SWIGWARN_LANG_CLASS_UNNAMED       513 %enddef
+%define SWIGWARN_LANG_DIRECTOR_VDESTRUCT  514 %enddef
+%define SWIGWARN_LANG_DISCARD_CONST       515 %enddef
+%define SWIGWARN_LANG_OVERLOAD_IGNORED    516 %enddef
+%define SWIGWARN_LANG_DIRECTOR_ABSTRACT   517 %enddef
+%define SWIGWARN_LANG_PORTABILITY_FILENAME 518 %enddef
+%define SWIGWARN_LANG_TEMPLATE_METHOD_IGNORE 519 %enddef
+%define SWIGWARN_LANG_SMARTPTR_MISSING    520 %enddef
+%define SWIGWARN_LANG_ILLEGAL_DESTRUCTOR  521 %enddef
+%define SWIGWARN_LANG_EXTEND_CONSTRUCTOR  522 %enddef
+%define SWIGWARN_LANG_EXTEND_DESTRUCTOR   523 %enddef
+
+/* -- Reserved (600-799) -- */
+
+/* -- Language module specific warnings (700 - 899) -- */
+
+
+%define SWIGWARN_D_TYPEMAP_CTYPE_UNDEF            700 %enddef
+%define SWIGWARN_D_TYPEMAP_IMTYPE_UNDEF           701 %enddef
+%define SWIGWARN_D_TYPEMAP_DTYPE_UNDEF            702 %enddef
+%define SWIGWARN_D_MULTIPLE_INHERITANCE           703 %enddef
+%define SWIGWARN_D_TYPEMAP_CLASSMOD_UNDEF         704 %enddef
+%define SWIGWARN_D_TYPEMAP_DBODY_UNDEF            705 %enddef
+%define SWIGWARN_D_TYPEMAP_DOUT_UNDEF             706 %enddef
+%define SWIGWARN_D_TYPEMAP_DIN_UNDEF              707 %enddef
+%define SWIGWARN_D_TYPEMAP_DDIRECTORIN_UNDEF      708 %enddef
+%define SWIGWARN_D_TYPEMAP_DCONSTRUCTOR_UNDEF     709 %enddef
+%define SWIGWARN_D_EXCODE_MISSING                 710 %enddef
+%define SWIGWARN_D_CANTHROW_MISSING               711 %enddef
+%define SWIGWARN_D_NO_DIRECTORCONNECT_ATTR        712 %enddef
+%define SWIGWARN_D_NAME_COLLISION                 713 %enddef
+
+/* please leave 700-719 free for D */
+
+%define SWIGWARN_SCILAB_TRUNCATED_NAME            720 %enddef
+
+/* please leave 720-739 free for Scilab */
+
+%define SWIGWARN_PYTHON_INDENT_MISMATCH           740 %enddef
+
+/* please leave 740-759 free for Python */
+
+%define SWIGWARN_RUBY_WRONG_NAME                  801 %enddef
+%define SWIGWARN_RUBY_MULTIPLE_INHERITANCE        802 %enddef
+
+/* please leave 800-809 free for Ruby */
+
+%define SWIGWARN_JAVA_TYPEMAP_JNI_UNDEF           810 %enddef
+%define SWIGWARN_JAVA_TYPEMAP_JTYPE_UNDEF         811 %enddef
+%define SWIGWARN_JAVA_TYPEMAP_JSTYPE_UNDEF        812 %enddef
+%define SWIGWARN_JAVA_MULTIPLE_INHERITANCE        813 %enddef
+%define SWIGWARN_JAVA_TYPEMAP_GETCPTR_UNDEF       814 %enddef
+%define SWIGWARN_JAVA_TYPEMAP_CLASSMOD_UNDEF      815 %enddef
+%define SWIGWARN_JAVA_TYPEMAP_JAVABODY_UNDEF      816 %enddef
+%define SWIGWARN_JAVA_TYPEMAP_JAVAOUT_UNDEF       817 %enddef
+%define SWIGWARN_JAVA_TYPEMAP_JAVAIN_UNDEF        818 %enddef
+%define SWIGWARN_JAVA_TYPEMAP_JAVADIRECTORIN_UNDEF    819 %enddef
+%define SWIGWARN_JAVA_TYPEMAP_JAVADIRECTOROUT_UNDEF   820 %enddef
+%define SWIGWARN_JAVA_TYPEMAP_INTERFACECODE_UNDEF 821 %enddef
+%define SWIGWARN_JAVA_COVARIANT_RET               822 %enddef
+%define SWIGWARN_JAVA_TYPEMAP_JAVACONSTRUCT_UNDEF 823 %enddef
+%define SWIGWARN_JAVA_TYPEMAP_DIRECTORIN_NODESC   824 %enddef
+%define SWIGWARN_JAVA_NO_DIRECTORCONNECT_ATTR     825 %enddef
+%define SWIGWARN_JAVA_NSPACE_WITHOUT_PACKAGE      826 %enddef
+
+/* please leave 810-829 free for Java */
+
+%define SWIGWARN_CSHARP_TYPEMAP_CTYPE_UNDEF       830 %enddef
+%define SWIGWARN_CSHARP_TYPEMAP_CSTYPE_UNDEF      831 %enddef
+%define SWIGWARN_CSHARP_TYPEMAP_CSWTYPE_UNDEF     832 %enddef
+%define SWIGWARN_CSHARP_MULTIPLE_INHERITANCE      833 %enddef
+%define SWIGWARN_CSHARP_TYPEMAP_GETCPTR_UNDEF     834 %enddef
+%define SWIGWARN_CSHARP_TYPEMAP_CLASSMOD_UNDEF    835 %enddef
+%define SWIGWARN_CSHARP_TYPEMAP_CSBODY_UNDEF      836 %enddef
+%define SWIGWARN_CSHARP_TYPEMAP_CSOUT_UNDEF       837 %enddef
+%define SWIGWARN_CSHARP_TYPEMAP_CSIN_UNDEF        838 %enddef
+%define SWIGWARN_CSHARP_TYPEMAP_CSDIRECTORIN_UNDEF    839 %enddef
+%define SWIGWARN_CSHARP_TYPEMAP_CSDIRECTOROUT_UNDEF   840 %enddef
+%define SWIGWARN_CSHARP_TYPEMAP_INTERFACECODE_UNDEF   841 %enddef
+%define SWIGWARN_CSHARP_COVARIANT_RET             842 %enddef
+%define SWIGWARN_CSHARP_TYPEMAP_CSCONSTRUCT_UNDEF 843 %enddef
+%define SWIGWARN_CSHARP_EXCODE                    844 %enddef
+%define SWIGWARN_CSHARP_CANTHROW                  845 %enddef
+%define SWIGWARN_CSHARP_NO_DIRECTORCONNECT_ATTR   846 %enddef
+
+/* please leave 830-849 free for C# */
+
+%define SWIGWARN_MODULA3_TYPEMAP_TYPE_UNDEF        850 %enddef
+%define SWIGWARN_MODULA3_TYPEMAP_GETCPTR_UNDEF     851 %enddef
+%define SWIGWARN_MODULA3_TYPEMAP_CLASSMOD_UNDEF    852 %enddef
+%define SWIGWARN_MODULA3_TYPEMAP_PTRCONSTMOD_UNDEF 853 %enddef
+%define SWIGWARN_MODULA3_TYPEMAP_MULTIPLE_RETURN   854 %enddef
+%define SWIGWARN_MODULA3_MULTIPLE_INHERITANCE      855 %enddef
+%define SWIGWARN_MODULA3_TYPECONSTRUCTOR_UNKNOWN   856 %enddef
+%define SWIGWARN_MODULA3_UNKNOWN_PRAGMA            857 %enddef
+%define SWIGWARN_MODULA3_BAD_ENUMERATION           858 %enddef
+%define SWIGWARN_MODULA3_DOUBLE_ID                 859 %enddef
+%define SWIGWARN_MODULA3_BAD_IMPORT                860 %enddef
+
+/* please leave 850-869 free for Modula 3 */
+
+%define SWIGWARN_PHP_MULTIPLE_INHERITANCE         870 %enddef
+%define SWIGWARN_PHP_UNKNOWN_PRAGMA               871 %enddef
+%define SWIGWARN_PHP_PUBLIC_BASE                  872 %enddef
+
+/* please leave 870-889 free for PHP */
+
+%define SWIGWARN_GO_NAME_CONFLICT                 890 %enddef
+
+/* please leave 890-899 free for Go */
+
+/* -- User defined warnings (900 - 999) -- */
+
diff --git a/share/swig/3.0.12/swigwarnings.swg b/share/swig/3.0.12/swigwarnings.swg
new file mode 100644
index 0000000..34c98fb
--- /dev/null
+++ b/share/swig/3.0.12/swigwarnings.swg
@@ -0,0 +1,129 @@
+/*
+  Include the internal swig macro codes. These macros correspond to
+  the one found in Source/Include/swigwarn.h plus the 'SWIG' prefix.
+  
+  For example, in the include file 'swigwarn.h' you will find
+
+    #define WARN_TYPEMAP_CHARLEAK ...
+
+  and in the 'swigwarn.swg' interface, you will see
+
+    %define SWIGWARN_TYPEMAP_CHARLEAK ...
+
+  This code can be used in warning filters as follows:
+
+    %warnfilter(SWIGWARN_TYPEMAP_CHARLEAK);
+
+  Warnings messages used in typemaps. Message names will be the same
+  as those in Lib/swigwarn.swg but with the suffix _MSG.
+   
+  For example, for the code SWIGWARN_TYPEMAP_CHARLEAK, once you use
+
+    %typemapmsg(CHARLEAK,<msg>);
+
+  you use the message in your typemap as
+
+    %typemap(varin,warning=SWIGWARN_TYPEMAP_CHARLEAK_MSG) char * 
+
+  while you suppress the warning using
+
+    %warnfilter(SWIGWARN_TYPEMAP_CHARLEAK);
+
+  as described above.
+*/
+
+/* -----------------------------------------------------------------------------
+ * SWIG warning codes
+ * ----------------------------------------------------------------------------- */
+
+%include <swigwarn.swg>
+
+/* -----------------------------------------------------------------------------
+ * Auxiliary macros
+ * ----------------------------------------------------------------------------- */
+
+/* Macro to define warning messages */
+#define %_warningmsg(Val, Msg...) `Val`":"Msg 
+#define %warningmsg(Val, Msg...) %_warningmsg(Val, Msg)
+
+/* -----------------------------------------------------------------------------
+ *  Typemap related warning messages
+ * ----------------------------------------------------------------------------- */
+
+%define SWIGWARN_TYPEMAP_CHARLEAK_MSG         "451:Setting a const char * variable may leak memory." %enddef
+%define SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG     "454:Setting a pointer/reference variable may leak memory." %enddef
+%define SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG    "470:Thread/reentrant unsafe wrapping, consider returning by value instead." %enddef
+%define SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG  "473:Returning a pointer or reference in a director method is not recommended." %enddef
+%define SWIGWARN_TYPEMAP_INITIALIZER_LIST_MSG "476:Initialization using std::initializer_list." %enddef
+
+/* -----------------------------------------------------------------------------
+ * Operator related warning messages 
+ * ----------------------------------------------------------------------------- */
+
+%define SWIGWARN_IGNORE_OPERATOR_NEW_MSG        "350:operator new ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_DELETE_MSG     "351:operator delete ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_PLUS_MSG       "352:operator+ ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_MINUS_MSG      "353:operator- ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_MUL_MSG        "354:operator* ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_DIV_MSG        "355:operator/ ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_MOD_MSG        "356:operator% ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_XOR_MSG        "357:operator^ ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_AND_MSG        "358:operator& ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_OR_MSG         "359:operator| ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_NOT_MSG        "360:operator~ ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_LNOT_MSG       "361:operator! ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_EQ_MSG         "362:operator= ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_LT_MSG         "363:operator< ignored" %enddef
+%define SWIGWARN_IGNORE_OPERATOR_GT_MSG         "364:operator> ignored" %enddef
+%define SWIGWARN_IGNORE_OPERATOR_PLUSEQ_MSG     "365:operator+= ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_MINUSEQ_MSG    "366:operator-= ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_MULEQ_MSG      "367:operator*= ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_DIVEQ_MSG      "368:operator/= ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_MODEQ_MSG      "369:operator%= ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_XOREQ_MSG      "370:operator^= ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_ANDEQ_MSG      "371:operator&= ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_OREQ_MSG       "372:operator|= ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_LSHIFT_MSG     "373:operator<< ignored" %enddef
+%define SWIGWARN_IGNORE_OPERATOR_RSHIFT_MSG     "374:operator>> ignored" %enddef
+%define SWIGWARN_IGNORE_OPERATOR_LSHIFTEQ_MSG   "375:operator<<= ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_RSHIFTEQ_MSG   "376:operator>>= ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_EQUALTO_MSG    "377:operator== ignored" %enddef
+%define SWIGWARN_IGNORE_OPERATOR_NOTEQUAL_MSG   "378:operator!= ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_LTEQUAL_MSG    "379:operator<= ignored" %enddef
+%define SWIGWARN_IGNORE_OPERATOR_GTEQUAL_MSG    "380:operator>= ignored" %enddef
+%define SWIGWARN_IGNORE_OPERATOR_LAND_MSG       "381:operator&& ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_LOR_MSG        "382:operator|| ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_PLUSPLUS_MSG   "383:operator++ ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_MINUSMINUS_MSG "384:operator-- ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_COMMA_MSG      "385:operator-- ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_ARROWSTAR_MSG  "386:operator->* ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_ARROW_MSG      "387:operator-> ignored" %enddef
+%define SWIGWARN_IGNORE_OPERATOR_CALL_MSG       "388:operator() ignored" %enddef
+%define SWIGWARN_IGNORE_OPERATOR_INDEX_MSG      "389:operator[] ignored (consider using %%extend)"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_UPLUS_MSG      "390:operator+ ignored" %enddef
+%define SWIGWARN_IGNORE_OPERATOR_UMINUS_MSG     "391:operator- ignored" %enddef
+%define SWIGWARN_IGNORE_OPERATOR_UMUL_MSG       "392:operator* ignored" %enddef
+%define SWIGWARN_IGNORE_OPERATOR_UAND_MSG       "393:operator& ignored" %enddef
+%define SWIGWARN_IGNORE_OPERATOR_NEWARR_MSG     "394:operator new[] ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_DELARR_MSG     "395:operator delete[] ignored"  %enddef
+%define SWIGWARN_IGNORE_OPERATOR_REF_MSG        "396:operator*() ignored" %enddef
+
+#define %ignoreoperator(Oper) %ignorewarn(SWIGWARN_IGNORE_OPERATOR_##Oper##_MSG)
+
+/* -----------------------------------------------------------------------------
+ * Macros for keyword and built-in names 
+ * ----------------------------------------------------------------------------- */
+
+#define %keywordwarn(msg...) %namewarn(%warningmsg(SWIGWARN_PARSE_KEYWORD, msg)) 
+#define %builtinwarn(msg...) %namewarn(%warningmsg(SWIGWARN_PARSE_BUILTIN_NAME, msg), %$isfunction)
+
+
+/* -----------------------------------------------------------------------------
+ * Warning filter feature
+ * ----------------------------------------------------------------------------- */
+
+#define %_warnfilter(filter...) %feature("warnfilter",`filter`)
+#define %warnfilter(filter...) %_warnfilter(filter)
+
+
+
diff --git a/share/swig/2.0.11/tcl/attribute.i b/share/swig/3.0.12/tcl/attribute.i
index 779716c..779716c 100644
--- a/share/swig/2.0.11/tcl/attribute.i
+++ b/share/swig/3.0.12/tcl/attribute.i
diff --git a/share/swig/2.0.11/tcl/carrays.i b/share/swig/3.0.12/tcl/carrays.i
index 0236672..0236672 100644
--- a/share/swig/2.0.11/tcl/carrays.i
+++ b/share/swig/3.0.12/tcl/carrays.i
diff --git a/share/swig/3.0.12/tcl/cdata.i b/share/swig/3.0.12/tcl/cdata.i
new file mode 100644
index 0000000..3679659
--- /dev/null
+++ b/share/swig/3.0.12/tcl/cdata.i
@@ -0,0 +1 @@
+%include <typemaps/cdata.swg>
diff --git a/share/swig/3.0.12/tcl/cmalloc.i b/share/swig/3.0.12/tcl/cmalloc.i
new file mode 100644
index 0000000..248f06b
--- /dev/null
+++ b/share/swig/3.0.12/tcl/cmalloc.i
@@ -0,0 +1 @@
+%include <typemaps/cmalloc.swg>
diff --git a/share/swig/2.0.11/tcl/cni.i b/share/swig/3.0.12/tcl/cni.i
index 10a1403..10a1403 100644
--- a/share/swig/2.0.11/tcl/cni.i
+++ b/share/swig/3.0.12/tcl/cni.i
diff --git a/share/swig/3.0.12/tcl/cpointer.i b/share/swig/3.0.12/tcl/cpointer.i
new file mode 100644
index 0000000..d824792
--- /dev/null
+++ b/share/swig/3.0.12/tcl/cpointer.i
@@ -0,0 +1 @@
+%include <typemaps/cpointer.swg>
diff --git a/share/swig/2.0.11/tcl/cstring.i b/share/swig/3.0.12/tcl/cstring.i
index ede9c59..ede9c59 100644
--- a/share/swig/2.0.11/tcl/cstring.i
+++ b/share/swig/3.0.12/tcl/cstring.i
diff --git a/share/swig/2.0.11/tcl/cwstring.i b/share/swig/3.0.12/tcl/cwstring.i
index b17ca76..b17ca76 100644
--- a/share/swig/2.0.11/tcl/cwstring.i
+++ b/share/swig/3.0.12/tcl/cwstring.i
diff --git a/share/swig/2.0.11/tcl/exception.i b/share/swig/3.0.12/tcl/exception.i
index 4d22797..4d22797 100644
--- a/share/swig/2.0.11/tcl/exception.i
+++ b/share/swig/3.0.12/tcl/exception.i
diff --git a/share/swig/2.0.11/tcl/factory.i b/share/swig/3.0.12/tcl/factory.i
index 46a0a87..46a0a87 100644
--- a/share/swig/2.0.11/tcl/factory.i
+++ b/share/swig/3.0.12/tcl/factory.i
diff --git a/share/swig/2.0.11/tcl/jstring.i b/share/swig/3.0.12/tcl/jstring.i
index 7fb7b89..7fb7b89 100644
--- a/share/swig/2.0.11/tcl/jstring.i
+++ b/share/swig/3.0.12/tcl/jstring.i
diff --git a/share/swig/2.0.11/tcl/std_common.i b/share/swig/3.0.12/tcl/std_common.i
index 0718fac..0718fac 100644
--- a/share/swig/2.0.11/tcl/std_common.i
+++ b/share/swig/3.0.12/tcl/std_common.i
diff --git a/share/swig/3.0.12/tcl/std_deque.i b/share/swig/3.0.12/tcl/std_deque.i
new file mode 100644
index 0000000..cb98f6c
--- /dev/null
+++ b/share/swig/3.0.12/tcl/std_deque.i
@@ -0,0 +1 @@
+%include <std/_std_deque.i>
diff --git a/share/swig/3.0.12/tcl/std_except.i b/share/swig/3.0.12/tcl/std_except.i
new file mode 100644
index 0000000..af98428
--- /dev/null
+++ b/share/swig/3.0.12/tcl/std_except.i
@@ -0,0 +1 @@
+%include <typemaps/std_except.swg>
diff --git a/share/swig/3.0.12/tcl/std_map.i b/share/swig/3.0.12/tcl/std_map.i
new file mode 100644
index 0000000..ade2b0a
--- /dev/null
+++ b/share/swig/3.0.12/tcl/std_map.i
@@ -0,0 +1,73 @@
+//
+// SWIG typemaps for std::map
+//
+// Common implementation
+
+%include <std_common.i>
+
+// ------------------------------------------------------------------------
+// std::map
+// ------------------------------------------------------------------------
+
+%{
+#include <map>
+%}
+%fragment("<algorithm>");
+%fragment("<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();
+            }
+        }
+    };
+
+// 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/3.0.12/tcl/std_pair.i b/share/swig/3.0.12/tcl/std_pair.i
new file mode 100644
index 0000000..1448d65
--- /dev/null
+++ b/share/swig/3.0.12/tcl/std_pair.i
@@ -0,0 +1,34 @@
+/* -----------------------------------------------------------------------------
+ * std_pair.i
+ *
+ * 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/tcl/std_string.i b/share/swig/3.0.12/tcl/std_string.i
index 5b31b28..5b31b28 100644
--- a/share/swig/2.0.11/tcl/std_string.i
+++ b/share/swig/3.0.12/tcl/std_string.i
diff --git a/share/swig/3.0.12/tcl/std_vector.i b/share/swig/3.0.12/tcl/std_vector.i
new file mode 100644
index 0000000..3fc0fd6
--- /dev/null
+++ b/share/swig/3.0.12/tcl/std_vector.i
@@ -0,0 +1,419 @@
+/* -----------------------------------------------------------------------------
+ * std_vector.i
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+
+// ------------------------------------------------------------------------
+// std::vector
+// 
+// The aim of all that follows would be to integrate std::vector with 
+// Tcl as much as possible, namely, to allow the user to pass and 
+// be returned Tcl lists.
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+// 
+//   -- f(std::vector< T >), f(const std::vector< T >&), f(const std::vector< T >*):
+//      the parameter being read-only, either a Tcl list or a
+//      previously wrapped std::vector< T > can be passed.
+//   -- f(std::vector< T >&), f(std::vector< T >*):
+//      the parameter must be modified; therefore, only a wrapped std::vector
+//      can be passed.
+//   -- std::vector< T > f():
+//      the vector is returned by copy; therefore, a Tcl list of T:s 
+//      is returned which is most easily used in other Tcl functions procs
+//   -- std::vector< T >& f(), std::vector< T >* f(), const std::vector< T >& f(),
+//      const std::vector< T >* f():
+//      the vector is returned by reference; therefore, a wrapped std::vector
+//      is returned
+// ------------------------------------------------------------------------
+
+%fragment("<string>");
+%fragment("<stdexcept>");
+%fragment("<algorithm>");
+%{
+#include <vector>
+
+Tcl_Obj* SwigString_FromString(const std::string &s) {
+    return Tcl_NewStringObj(s.data(), (int)s.length());
+}
+
+int Tcl_GetBoolFromObj(Tcl_Interp *interp, Tcl_Obj *o, bool *val) {
+  int v;
+  int res = Tcl_GetBooleanFromObj(interp, o, &v);
+  if (res == TCL_OK) {
+    *val = v ? true : false;
+  }
+  return res;  
+}
+ 
+int SwigString_AsString(Tcl_Interp *interp, Tcl_Obj *o, std::string *val) {
+    int len;
+    const char* temp = Tcl_GetStringFromObj(o, &len);
+    if (temp == NULL)
+        return TCL_ERROR;
+    val->assign(temp, len);
+    return TCL_OK;
+}
+
+// behaviour of this is such as the real Tcl_GetIntFromObj
+template <typename Type>
+int SwigInt_As(Tcl_Interp *interp, Tcl_Obj *o, Type *val) {
+    int temp_val, return_val;
+    return_val = Tcl_GetIntFromObj(interp, o, &temp_val);
+    *val = (Type) temp_val;
+    return return_val;
+}
+
+// behaviour of this is such as the real Tcl_GetDoubleFromObj
+template <typename Type>
+int SwigDouble_As(Tcl_Interp *interp, Tcl_Obj *o, Type *val) {
+    int return_val;
+    double temp_val;
+    return_val = Tcl_GetDoubleFromObj(interp, o, &temp_val);
+    *val = (Type) temp_val;
+    return return_val;
+}
+
+%}
+
+// exported class
+
+namespace std {
+    
+    template<class T> class vector {
+        %typemap(in) vector< T > (std::vector< T > *v) {
+            Tcl_Obj **listobjv;
+            int       nitems;
+            int       i;
+            T*        temp;
+
+            if (SWIG_ConvertPtr($input, (void **) &v, \
+                                $&1_descriptor, 0) == 0){
+                $1 = *v;
+            } else {
+                // It isn't a vector< T > so it should be a list of T's
+                if(Tcl_ListObjGetElements(interp, $input, \
+                                          &nitems, &listobjv) == TCL_ERROR)
+                    return TCL_ERROR;
+                $1 = std::vector< T >();
+                for (i = 0; i < nitems; i++) {
+                    if ((SWIG_ConvertPtr(listobjv[i],(void **) &temp,
+                                         $descriptor(T *),0)) != 0) {
+                        char message[] = 
+                            "list of " #T " expected";
+                        Tcl_SetResult(interp, message, TCL_VOLATILE);
+                        return TCL_ERROR;
+                    }
+                    $1.push_back(*temp);
+                } 
+            }
+        }
+
+        %typemap(in) const vector< T >* (std::vector< T > *v, std::vector< T > w),
+                     const vector< T >& (std::vector< T > *v, std::vector< T > w) {
+            Tcl_Obj **listobjv;
+            int       nitems;
+            int       i;
+            T*        temp;
+
+            if(SWIG_ConvertPtr($input, (void **) &v, \
+                               $&1_descriptor, 0) == 0) {
+                $1 = v;
+            } else {
+                // It isn't a vector< T > so it should be a list of T's
+                if(Tcl_ListObjGetElements(interp, $input, 
+                                          &nitems, &listobjv) == TCL_ERROR)
+                    return TCL_ERROR;
+                w = std::vector< T >();
+                for (i = 0; i < nitems; i++) {
+                    if ((SWIG_ConvertPtr(listobjv[i],(void **) &temp,
+                                         $descriptor(T *),0)) != 0) {
+                        char message[] = 
+                            "list of " #T " expected";
+                        Tcl_SetResult(interp, message, TCL_VOLATILE);
+                        return TCL_ERROR;
+                    }
+                    w.push_back(*temp);
+                } 
+                $1 = &w;
+            }
+        }
+
+        %typemap(out) vector< T > {
+            for (unsigned int i=0; i<$1.size(); i++) {
+                T* ptr = new T((($1_type &)$1)[i]);
+                Tcl_ListObjAppendElement(interp, $result, \
+                                         SWIG_NewInstanceObj(ptr, 
+                                                             $descriptor(T *), 
+                                                             0));
+            }
+        }
+
+        %typecheck(SWIG_TYPECHECK_VECTOR) vector< T > {
+            Tcl_Obj **listobjv;
+            int       nitems;
+            T*        temp;
+            std::vector< T > *v;
+            
+            if(SWIG_ConvertPtr($input, (void **) &v, \
+                               $&1_descriptor, 0) == 0) {
+                /* wrapped vector */
+                $1 = 1;
+            } else {
+                // It isn't a vector< T > so it should be a list of T's
+                if(Tcl_ListObjGetElements(interp, $input, 
+                                          &nitems, &listobjv) == TCL_ERROR)
+                    $1 = 0;
+                else
+                    if (nitems == 0)
+                        $1 = 1;
+                //check the first value to see if it is of correct type
+                    else if ((SWIG_ConvertPtr(listobjv[0],
+                                              (void **) &temp, 
+                                              $descriptor(T *),0)) != 0)
+                        $1 = 0;
+                    else
+                        $1 = 1;
+            }
+        }
+        
+        %typecheck(SWIG_TYPECHECK_VECTOR) const vector< T >&,
+                                          const vector< T >* {
+            Tcl_Obj **listobjv;
+            int       nitems;
+            T*         temp;
+            std::vector< T > *v;
+
+            if(SWIG_ConvertPtr($input, (void **) &v, \
+                               $1_descriptor, 0) == 0){
+                /* wrapped vector */
+                $1 = 1;
+            } else {
+                // It isn't a vector< T > so it should be a list of T's
+                if(Tcl_ListObjGetElements(interp, $input, 
+                                          &nitems, &listobjv) == TCL_ERROR)
+                    $1 = 0;
+                else
+                    if (nitems == 0)
+                        $1 = 1;
+                //check the first value to see if it is of correct type
+                    else if ((SWIG_ConvertPtr(listobjv[0],
+                                              (void **) &temp,
+                                              $descriptor(T *),0)) != 0)
+                        $1 = 0;
+                    else
+                        $1 = 1;
+            }
+        }
+      
+      public:
+        vector(unsigned int size = 0);
+        vector(unsigned int size, const T& value);
+        vector(const vector< T > &);
+
+        unsigned int size() const;
+        bool empty() const;
+        void clear();
+        %rename(push) push_back;
+        void push_back(const T& x);
+        %extend {
+            T pop() throw (std::out_of_range) {
+                if (self->size() == 0)
+                    throw std::out_of_range("pop from empty vector");
+                T x = self->back();
+                self->pop_back();
+                return x;
+            }
+            T& get(int i) throw (std::out_of_range) {
+                int size = int(self->size());
+                if (i<0) i += 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 T& x) throw (std::out_of_range) {
+                int size = int(self->size());
+                if (i<0) i+= size;
+                if (i>=0 && i<size)
+                    (*self)[i] = x;
+                else
+                    throw std::out_of_range("vector index out of range");
+            }
+        }
+    };
+
+
+    // specializations for built-ins
+
+    %define specialize_std_vector(T, CONVERT_FROM, CONVERT_TO)
+    template<> class vector< T > {
+
+        %typemap(in) vector< T > (std::vector< T > *v){
+            Tcl_Obj **listobjv;
+            int       nitems;
+            int       i;
+            T         temp;
+
+            if(SWIG_ConvertPtr($input, (void **) &v, \
+                               $&1_descriptor, 0) == 0) {
+                $1 = *v;
+            } else {
+                // It isn't a vector< T > so it should be a list of T's
+                if(Tcl_ListObjGetElements(interp, $input, 
+                                          &nitems, &listobjv) == TCL_ERROR)
+                    return TCL_ERROR;					      
+                $1 = std::vector< T >();
+                for (i = 0; i < nitems; i++) {
+                    if (CONVERT_FROM(interp, listobjv[i], &temp) == TCL_ERROR)
+                        return TCL_ERROR;
+                    $1.push_back(temp);
+                } 
+            }
+        }
+      
+        %typemap(in) const vector< T >& (std::vector< T > *v,std::vector< T > w),
+                     const vector< T >* (std::vector< T > *v,std::vector< T > w) {
+            Tcl_Obj **listobjv;
+            int       nitems;
+            int       i;
+            T         temp;
+
+            if(SWIG_ConvertPtr($input, (void **) &v, \
+                               $1_descriptor, 0) == 0) {
+                $1 = v;
+            } else {
+                // It isn't a vector< T > so it should be a list of T's
+                if(Tcl_ListObjGetElements(interp, $input, 
+                                          &nitems, &listobjv) == TCL_ERROR)
+                    return TCL_ERROR;
+                w = std::vector< T >();
+                for (i = 0; i < nitems; i++) {
+                    if (CONVERT_FROM(interp, listobjv[i], &temp) == TCL_ERROR)
+                        return TCL_ERROR;
+                    w.push_back(temp);
+                } 
+                $1 = &w;
+            }
+        }
+
+        %typemap(out) vector< T > {
+            for (unsigned int i=0; i<$1.size(); i++) {
+                Tcl_ListObjAppendElement(interp, $result, \
+                                         CONVERT_TO((($1_type &)$1)[i]));
+            }
+        }
+       
+        %typecheck(SWIG_TYPECHECK_VECTOR) vector< T > {
+            Tcl_Obj **listobjv;
+            int       nitems;
+            T         temp;
+            std::vector< T > *v;
+
+            if(SWIG_ConvertPtr($input, (void **) &v, \
+                               $&1_descriptor, 0) == 0){
+                /* wrapped vector */
+                $1 = 1;
+            } else {
+                // It isn't a vector< T > so it should be a list of T's
+                if(Tcl_ListObjGetElements(interp, $input, 
+                                          &nitems, &listobjv) == TCL_ERROR)
+                    $1 = 0;
+                else
+                    if (nitems == 0)
+                        $1 = 1;
+                //check the first value to see if it is of correct type
+                if (CONVERT_FROM(interp, listobjv[0], &temp) == TCL_ERROR)
+                    $1 = 0;
+                else
+                    $1 = 1;
+            }
+        }      
+
+        %typecheck(SWIG_TYPECHECK_VECTOR) const vector< T >&,
+	                                      const vector< T >*{
+            Tcl_Obj **listobjv;
+            int       nitems;
+            T         temp;
+            std::vector< T > *v;
+
+            if(SWIG_ConvertPtr($input, (void **) &v, \
+                               $1_descriptor, 0) == 0){
+                /* wrapped vector */
+                $1 = 1;
+            } else {
+                // It isn't a vector< T > so it should be a list of T's
+                if(Tcl_ListObjGetElements(interp, $input, 
+                                          &nitems, &listobjv) == TCL_ERROR)
+                    $1 = 0;
+                else
+                    if (nitems == 0)
+                        $1 = 1;
+                //check the first value to see if it is of correct type
+                if (CONVERT_FROM(interp, listobjv[0], &temp) == TCL_ERROR)
+                    $1 = 0;
+                else
+                    $1 = 1;
+            }
+        }
+        
+      public:
+        vector(unsigned int size = 0);
+        vector(unsigned int size, const T& value);
+        vector(const vector< T > &);
+
+        unsigned int size() const;
+        bool empty() const;
+        void clear();
+        %rename(push) push_back;
+        void push_back(T x);
+        %extend {
+            T pop() throw (std::out_of_range) {
+                if (self->size() == 0)
+                    throw std::out_of_range("pop from empty vector");
+                T x = self->back();
+                self->pop_back();
+                return x;
+            }
+            T get(int i) throw (std::out_of_range) {
+                int size = int(self->size());
+                if (i<0) i += size;
+                if (i>=0 && i<size)
+                    return (*self)[i];
+                else
+                    throw std::out_of_range("vector index out of range");
+            }
+            void set(int i, T x) throw (std::out_of_range) {
+                int size = int(self->size());
+                if (i<0) i+= size;
+                if (i>=0 && i<size)
+                    (*self)[i] = x;
+                else
+                    throw std::out_of_range("vector index out of range");
+            }
+        }
+    };
+    %enddef
+
+    specialize_std_vector(bool, Tcl_GetBoolFromObj, Tcl_NewBooleanObj);
+    specialize_std_vector(char, SwigInt_As<char>,Tcl_NewIntObj);
+    specialize_std_vector(int, Tcl_GetIntFromObj,Tcl_NewIntObj);
+    specialize_std_vector(short, SwigInt_As<short>, Tcl_NewIntObj);
+    specialize_std_vector(long, SwigInt_As<long>, Tcl_NewIntObj);
+    specialize_std_vector(unsigned char, 
+                          SwigInt_As<unsigned char>, Tcl_NewIntObj);
+    specialize_std_vector(unsigned int, 
+                          SwigInt_As<unsigned int>, Tcl_NewIntObj);
+    specialize_std_vector(unsigned short, 
+                          SwigInt_As<unsigned short>, Tcl_NewIntObj);
+    specialize_std_vector(unsigned long, 
+                          SwigInt_As<unsigned long>, Tcl_NewIntObj);
+    specialize_std_vector(double, Tcl_GetDoubleFromObj, Tcl_NewDoubleObj);
+    specialize_std_vector(float, SwigDouble_As<float>, Tcl_NewDoubleObj);
+    specialize_std_vector(std::string, 
+                          SwigString_AsString, SwigString_FromString);
+
+}
+
+
diff --git a/share/swig/2.0.11/tcl/std_wstring.i b/share/swig/3.0.12/tcl/std_wstring.i
index f132614..f132614 100644
--- a/share/swig/2.0.11/tcl/std_wstring.i
+++ b/share/swig/3.0.12/tcl/std_wstring.i
diff --git a/share/swig/2.0.11/tcl/stl.i b/share/swig/3.0.12/tcl/stl.i
index 40c7584..40c7584 100644
--- a/share/swig/2.0.11/tcl/stl.i
+++ b/share/swig/3.0.12/tcl/stl.i
diff --git a/share/swig/2.0.11/tcl/tcl8.swg b/share/swig/3.0.12/tcl/tcl8.swg
index 5da1bc0..5da1bc0 100644
--- a/share/swig/2.0.11/tcl/tcl8.swg
+++ b/share/swig/3.0.12/tcl/tcl8.swg
diff --git a/share/swig/2.0.11/tcl/tclapi.swg b/share/swig/3.0.12/tcl/tclapi.swg
index 33dc324..33dc324 100644
--- a/share/swig/2.0.11/tcl/tclapi.swg
+++ b/share/swig/3.0.12/tcl/tclapi.swg
diff --git a/share/swig/2.0.11/tcl/tclerrors.swg b/share/swig/3.0.12/tcl/tclerrors.swg
index 889d3ad..889d3ad 100644
--- a/share/swig/2.0.11/tcl/tclerrors.swg
+++ b/share/swig/3.0.12/tcl/tclerrors.swg
diff --git a/share/swig/2.0.11/tcl/tclfragments.swg b/share/swig/3.0.12/tcl/tclfragments.swg
index ba6398c..ba6398c 100644
--- a/share/swig/2.0.11/tcl/tclfragments.swg
+++ b/share/swig/3.0.12/tcl/tclfragments.swg
diff --git a/share/swig/2.0.11/tcl/tclinit.swg b/share/swig/3.0.12/tcl/tclinit.swg
index 3140bdc..3140bdc 100644
--- a/share/swig/2.0.11/tcl/tclinit.swg
+++ b/share/swig/3.0.12/tcl/tclinit.swg
diff --git a/share/swig/2.0.11/tcl/tclinterp.i b/share/swig/3.0.12/tcl/tclinterp.i
index 3b45b6d..3b45b6d 100644
--- a/share/swig/2.0.11/tcl/tclinterp.i
+++ b/share/swig/3.0.12/tcl/tclinterp.i
diff --git a/share/swig/2.0.11/tcl/tclkw.swg b/share/swig/3.0.12/tcl/tclkw.swg
index e96e885..e96e885 100644
--- a/share/swig/2.0.11/tcl/tclkw.swg
+++ b/share/swig/3.0.12/tcl/tclkw.swg
diff --git a/share/swig/2.0.11/tcl/tclmacros.swg b/share/swig/3.0.12/tcl/tclmacros.swg
index ab7bace..ab7bace 100644
--- a/share/swig/2.0.11/tcl/tclmacros.swg
+++ b/share/swig/3.0.12/tcl/tclmacros.swg
diff --git a/share/swig/2.0.11/tcl/tclopers.swg b/share/swig/3.0.12/tcl/tclopers.swg
index f113ccd..f113ccd 100644
--- a/share/swig/2.0.11/tcl/tclopers.swg
+++ b/share/swig/3.0.12/tcl/tclopers.swg
diff --git a/share/swig/3.0.12/tcl/tclprimtypes.swg b/share/swig/3.0.12/tcl/tclprimtypes.swg
new file mode 100644
index 0000000..3b6d04f
--- /dev/null
+++ b/share/swig/3.0.12/tcl/tclprimtypes.swg
@@ -0,0 +1,247 @@
+/* ------------------------------------------------------------
+ * Primitive Types
+ * ------------------------------------------------------------ */
+
+/* boolean */
+
+%fragment(SWIG_From_frag(bool),"header") {
+  %define_as(SWIG_From_dec(bool),           Tcl_NewBooleanObj)
+}
+
+%fragment(SWIG_AsVal_frag(bool),"header") {
+SWIGINTERN int
+SWIG_AsVal_dec(bool)(Tcl_Obj *obj, bool *val)
+{
+  int v;
+  if (Tcl_GetBooleanFromObj(0, obj, &v) == TCL_OK) {
+    if (val) *val = v ? true : false;
+    return SWIG_OK;
+  }
+  return SWIG_TypeError;
+}
+}
+
+/* long */
+
+%fragment(SWIG_From_frag(long),"header",
+	  fragment="<limits.h>") {
+SWIGINTERNINLINE Tcl_Obj* 
+SWIG_From_dec(long)(long value)
+{
+  if (((long) INT_MIN <= value) && (value <= (long) INT_MAX)) {
+    return Tcl_NewIntObj(%numeric_cast(value,int));
+  } else {
+    return Tcl_NewLongObj(value);
+  }
+}
+}
+
+%fragment(SWIG_AsVal_frag(long),"header") {
+SWIGINTERN int
+SWIG_AsVal_dec(long)(Tcl_Obj *obj, long* val)
+{
+  long v;
+  if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
+    if (val) *val = (long) v;
+    return SWIG_OK;
+  }
+  return SWIG_TypeError;
+}
+}
+
+/* unsigned long */
+
+%fragment(SWIG_From_frag(unsigned long),"header",
+	  fragment=SWIG_From_frag(long),
+	  fragment="<stdio.h>") {
+SWIGINTERNINLINE Tcl_Obj* 
+SWIG_From_dec(unsigned long)(unsigned long value)
+{
+  if (value < (unsigned long) LONG_MAX) {
+    return SWIG_From(long)(%numeric_cast(value, long));
+  } else {
+    char temp[256]; 
+    sprintf(temp, "%lu", value);
+    return Tcl_NewStringObj(temp,-1);
+  }
+}
+}
+
+%fragment(SWIG_AsVal_frag(unsigned long),"header",
+	  fragment="<limits.h>") {
+SWIGINTERN int
+SWIG_AsVal_dec(unsigned long)(Tcl_Obj *obj, unsigned long *val) {
+  long v;
+  if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
+    if (v >= 0) {
+      if (val) *val = (unsigned long) v;
+      return SWIG_OK;
+    }
+    /* If v is negative, then this could be a negative number, or an
+       unsigned value which doesn't fit in a signed long, so try to
+       get it as a string so we can distinguish these cases. */
+  }
+  {
+    int len = 0;
+    const char *nptr = Tcl_GetStringFromObj(obj, &len);
+    if (nptr && len > 0) {
+      char *endptr;
+      unsigned long v;
+      if (*nptr == '-') return SWIG_OverflowError;
+      errno = 0;
+      v = strtoul(nptr, &endptr,0);
+      if (nptr[0] == '\0' || *endptr != '\0')
+	return SWIG_TypeError;
+      if (v == ULONG_MAX && errno == ERANGE) {
+	errno = 0;
+	return SWIG_OverflowError;
+      } else {
+	if (*endptr == '\0') {
+	  if (val) *val = v;
+	  return SWIG_OK;
+	}
+      }
+    }
+  }
+  
+  return SWIG_TypeError;
+}
+}
+
+/* long long */
+
+%fragment(SWIG_From_frag(long long),"header",
+	  fragment=SWIG_From_frag(long),
+	  fragment="SWIG_LongLongAvailable",
+	  fragment="<stdio.h>") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERNINLINE Tcl_Obj* 
+SWIG_From_dec(long long)(long long value)
+{
+  if (((long long) LONG_MIN <= value) && (value <= (long long) LONG_MAX)) {
+    return SWIG_From(long)(%numeric_cast(value,long));
+  } else {    
+    char temp[256]; 
+    sprintf(temp, "%lld", value);
+    return Tcl_NewStringObj(temp,-1);
+  }
+}
+%#endif
+}
+
+%fragment(SWIG_AsVal_frag(long long),"header",
+	  fragment="SWIG_LongLongAvailable",
+	  fragment="<stdlib.h>") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERN int
+SWIG_AsVal_dec(long long)(Tcl_Obj *obj, long long *val)
+{
+  long v;
+  if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
+    if (val) *val = v;
+    return SWIG_OK;
+  } else {
+    int len = 0;
+    const char *nptr = Tcl_GetStringFromObj(obj, &len);
+    if (nptr && len > 0) {
+      char *endptr;
+      long long v;
+      errno = 0;
+      v = strtoll(nptr, &endptr,0);
+      if (nptr[0] == '\0' || *endptr != '\0')
+	return SWIG_TypeError;
+      if ((v == LLONG_MAX || v == LLONG_MIN) && errno == ERANGE) {
+	errno = 0;
+	return SWIG_OverflowError;
+      } else {
+	if (*endptr == '\0') {
+	  if (val) *val = v;
+	  return SWIG_OK;
+	}
+      }
+    }
+  }
+  return SWIG_TypeError;
+}
+%#endif
+}
+
+/* unsigned long long */
+
+%fragment(SWIG_From_frag(unsigned long long),"header",
+	  fragment=SWIG_From_frag(long long),
+	  fragment="SWIG_LongLongAvailable",
+	  fragment="<stdio.h>") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERNINLINE Tcl_Obj* 
+SWIG_From_dec(unsigned long long)(unsigned long long value)
+{
+  if (value < (unsigned long long) LONG_MAX) {
+    return SWIG_From(long long)(%numeric_cast(value, long long));
+  } else {
+    char temp[256]; 
+    sprintf(temp, "%llu", value);
+    return Tcl_NewStringObj(temp,-1);
+  }
+}
+%#endif
+}
+
+%fragment(SWIG_AsVal_frag(unsigned long long),"header",
+	  fragment=SWIG_AsVal_frag(unsigned long),
+	  fragment="SWIG_LongLongAvailable",
+	  fragment="<stdlib.h>") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERN int
+SWIG_AsVal_dec(unsigned long long)(Tcl_Obj *obj, unsigned long long *val)
+{
+  long v;
+  if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
+    if (val) *val = (unsigned long) v;
+    return SWIG_OK;
+  } else {
+    int len = 0;
+    const char *nptr = Tcl_GetStringFromObj(obj, &len);
+    if (nptr && len > 0) {
+      char *endptr;
+      unsigned long long v;
+      if (*nptr == '-') return SWIG_OverflowError;
+      errno = 0;
+      v = strtoull(nptr, &endptr,0);
+      if (nptr[0] == '\0' || *endptr != '\0')
+	return SWIG_TypeError;
+      if (v == ULLONG_MAX && errno == ERANGE) {
+	errno = 0;
+	return SWIG_OverflowError;
+      } else {
+	if (*endptr == '\0') {
+	  if (val) *val = v;
+	  return SWIG_OK;
+	}
+      }
+    }
+  }
+  return SWIG_TypeError;
+}
+%#endif
+}
+
+/* double */
+
+%fragment(SWIG_From_frag(double),"header") {
+  %define_as(SWIG_From(double),         Tcl_NewDoubleObj)
+}
+
+%fragment(SWIG_AsVal_frag(double),"header") {
+SWIGINTERN int
+SWIG_AsVal_dec(double)(Tcl_Obj *obj, double *val)
+{
+  double v;
+  if (Tcl_GetDoubleFromObj(0, obj, &v) == TCL_OK) {
+    if (val) *val = v;
+    return SWIG_OK;
+  }
+  return SWIG_TypeError;
+}
+}
+
diff --git a/share/swig/2.0.11/tcl/tclresult.i b/share/swig/3.0.12/tcl/tclresult.i
index c63b3ee..c63b3ee 100644
--- a/share/swig/2.0.11/tcl/tclresult.i
+++ b/share/swig/3.0.12/tcl/tclresult.i
diff --git a/share/swig/3.0.12/tcl/tclrun.swg b/share/swig/3.0.12/tcl/tclrun.swg
new file mode 100644
index 0000000..f671ba2
--- /dev/null
+++ b/share/swig/3.0.12/tcl/tclrun.swg
@@ -0,0 +1,690 @@
+/* -----------------------------------------------------------------------------
+ * tclrun.swg
+ *
+ * This file contains the runtime support for Tcl modules and includes
+ * code for managing global variables and pointer type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* Common SWIG API */
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(oc, ptr, ty, flags)             SWIG_Tcl_ConvertPtr(interp, oc, ptr, ty, flags)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Tcl_NewPointerObj(ptr, type, flags)
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Tcl_ConvertPacked(interp, obj, ptr, sz, ty)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Tcl_NewPackedObj(ptr, sz, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_Tcl_ConvertPtr(interp, obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(thisvalue, type, flags)     SWIG_Tcl_NewInstanceObj(interp, thisvalue, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Tcl_ConvertPtr(interp, obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Tcl_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Tcl_ConvertPacked(interp,obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Tcl_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Tcl_GetModule((Tcl_Interp *) (clientdata))	     
+#define SWIG_SetModule(clientdata, pointer)          	SWIG_Tcl_SetModule((Tcl_Interp *) (clientdata), pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Tcl_ErrorType(code)                                      
+#define SWIG_Error(code, msg)            		SWIG_Tcl_SetErrorMsg(interp, SWIG_Tcl_ErrorType(code), msg)
+#define SWIG_fail                        		goto fail						    
+
+
+/* Tcl-specific SWIG API */
+
+#define SWIG_Acquire(ptr)                               SWIG_Tcl_Acquire(ptr)                                     
+#define SWIG_MethodCommand                           	SWIG_Tcl_MethodCommand				       
+#define SWIG_Disown(ptr)                             	SWIG_Tcl_Disown(ptr)				       
+#define SWIG_ConvertPtrFromString(c, ptr, ty, flags) 	SWIG_Tcl_ConvertPtrFromString(interp, c, ptr, ty, flags)  
+#define SWIG_MakePtr(c, ptr, ty, flags)              	SWIG_Tcl_MakePtr(c, ptr, ty, flags)		       
+#define SWIG_PointerTypeFromString(c)                	SWIG_Tcl_PointerTypeFromString(c)			       
+#define SWIG_GetArgs                                 	SWIG_Tcl_GetArgs					       
+#define SWIG_GetConstantObj(key)                     	SWIG_Tcl_GetConstantObj(key)			       
+#define SWIG_ObjectConstructor                       	SWIG_Tcl_ObjectConstructor				       
+#define SWIG_Thisown(ptr)                            	SWIG_Tcl_Thisown(ptr)				       
+#define SWIG_ObjectDelete                            	SWIG_Tcl_ObjectDelete				       
+
+
+#define SWIG_TCL_DECL_ARGS_2(arg1, arg2)                (Tcl_Interp *interp SWIGUNUSED, arg1, arg2)
+#define SWIG_TCL_CALL_ARGS_2(arg1, arg2)                (interp, arg1, arg2)
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+#define SWIG_GetConstant        SWIG_GetConstantObj
+#define SWIG_Tcl_GetConstant    SWIG_Tcl_GetConstantObj
+
+#if TCL_MAJOR_VERSION >= 8 && TCL_MINOR_VERSION >= 5
+#define SWIG_TCL_HASHTABLE_INIT {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+#else
+#define SWIG_TCL_HASHTABLE_INIT {0}
+#endif
+
+#include "assert.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Object support */
+
+SWIGRUNTIME Tcl_HashTable*
+SWIG_Tcl_ObjectTable(void) {
+  static Tcl_HashTable  swigobjectTable;
+  static int            swigobjectTableinit = 0;
+  if (!swigobjectTableinit) {
+    Tcl_InitHashTable(&swigobjectTable, TCL_ONE_WORD_KEYS);
+    swigobjectTableinit = 1;
+  }
+  return &swigobjectTable;
+}
+
+/* Acquire ownership of a pointer */
+SWIGRUNTIME void
+SWIG_Tcl_Acquire(void *ptr) {
+  int newobj;
+  Tcl_CreateHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr, &newobj);
+}
+
+SWIGRUNTIME int
+SWIG_Tcl_Thisown(void *ptr) {
+  if (Tcl_FindHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr)) {
+    return 1;
+  }
+  return 0;
+}
+
+/* Disown a pointer.  Returns 1 if we owned it to begin with */
+SWIGRUNTIME int
+SWIG_Tcl_Disown(void *ptr) {
+  Tcl_HashEntry *entryPtr = Tcl_FindHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr);
+  if (entryPtr) {
+    Tcl_DeleteHashEntry(entryPtr);
+    return 1;
+  }
+  return 0;
+}
+
+/* Convert a pointer value */
+SWIGRUNTIME int
+SWIG_Tcl_ConvertPtrFromString(Tcl_Interp *interp, const char *c, void **ptr, swig_type_info *ty, int flags) {
+  swig_cast_info *tc;
+  /* Pointer values must start with leading underscore */
+  while (*c != '_') {
+    *ptr = (void *) 0;
+    if (strcmp(c,"NULL") == 0) return SWIG_OK;
+
+    /* Empty string: not a pointer */
+    if (*c == 0) return SWIG_ERROR; 
+
+    /* Hmmm. It could be an object name. */
+
+    /* Check if this is a command at all. Prevents <c> cget -this         */
+    /* from being called when c is not a command, firing the unknown proc */
+    if (Tcl_VarEval(interp,"info commands ", c, (char *) NULL) == TCL_OK) {
+      Tcl_Obj *result = Tcl_GetObjResult(interp);
+      if (*(Tcl_GetStringFromObj(result, NULL)) == 0) {
+        /* It's not a command, so it can't be a pointer */
+        Tcl_ResetResult(interp);
+        return SWIG_ERROR;
+      }
+    } else {
+      /* This will only fail if the argument is multiple words. */
+      /* Multiple words are also not commands.                  */
+      Tcl_ResetResult(interp);
+      return SWIG_ERROR;
+    }
+
+    /* Check if this is really a SWIG pointer */
+    if (Tcl_VarEval(interp,c," cget -this", (char *) NULL) != TCL_OK) {
+      Tcl_ResetResult(interp);
+      return SWIG_ERROR;
+    }
+
+    c = Tcl_GetStringFromObj(Tcl_GetObjResult(interp), NULL);
+  }
+
+  c++;
+  c = SWIG_UnpackData(c,ptr,sizeof(void *));
+  if (ty) {
+    tc = c ? SWIG_TypeCheck(c,ty) : 0;
+    if (!tc) {
+      return SWIG_ERROR;
+    }
+    if (flags & SWIG_POINTER_DISOWN) {
+      SWIG_Disown((void *) *ptr);
+    }
+    {
+      int newmemory = 0;
+      *ptr = SWIG_TypeCast(tc,(void *) *ptr,&newmemory);
+      assert(!newmemory); /* newmemory handling not yet implemented */
+    }
+  }
+  return SWIG_OK;
+}
+
+/* Convert a pointer value */
+SWIGRUNTIMEINLINE int
+SWIG_Tcl_ConvertPtr(Tcl_Interp *interp, Tcl_Obj *oc, void **ptr, swig_type_info *ty, int flags) {
+  return SWIG_Tcl_ConvertPtrFromString(interp, Tcl_GetStringFromObj(oc,NULL), ptr, ty, flags);
+}
+
+/* Convert a pointer value */
+SWIGRUNTIME char *
+SWIG_Tcl_PointerTypeFromString(char *c) {
+  char d;
+  /* Pointer values must start with leading underscore. NULL has no type */
+  if (*c != '_') {
+    return 0;
+  }
+  c++;
+  /* Extract hex value from pointer */
+  while ((d = *c)) {
+    if (!(((d >= '0') && (d <= '9')) || ((d >= 'a') && (d <= 'f')))) break;
+    c++;
+  }
+  return c;
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Tcl_ConvertPacked(Tcl_Interp *SWIGUNUSEDPARM(interp) , Tcl_Obj *obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c;
+
+  if (!obj) goto type_error;
+  c = Tcl_GetStringFromObj(obj,NULL);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') goto type_error;
+  c++;
+  c = SWIG_UnpackData(c,ptr,sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c,ty);
+    if (!tc) goto type_error;
+  }
+  return SWIG_OK;
+
+ type_error:
+
+  return SWIG_ERROR;
+}
+
+
+/* Take a pointer and convert it to a string */
+SWIGRUNTIME void
+SWIG_Tcl_MakePtr(char *c, void *ptr, swig_type_info *ty, int SWIGUNUSEDPARM(flags)) {
+  if (ptr) {
+    *(c++) = '_';
+    c = SWIG_PackData(c,&ptr,sizeof(void *));
+    strcpy(c,ty->name);
+  } else {
+    strcpy(c,"NULL");
+  }
+}
+
+/* Create a new pointer object */
+SWIGRUNTIMEINLINE Tcl_Obj *
+SWIG_Tcl_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
+  Tcl_Obj *robj;
+  char result[SWIG_BUFFER_SIZE];
+  SWIG_MakePtr(result,ptr,type,flags);
+  robj = Tcl_NewStringObj(result,-1);
+  return robj;
+}
+
+SWIGRUNTIME Tcl_Obj *
+SWIG_Tcl_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  strcpy(r,type->name);
+  return Tcl_NewStringObj(result,-1);
+}
+
+/* -----------------------------------------------------------------------------*
+ *  Get type list 
+ * -----------------------------------------------------------------------------*/
+
+SWIGRUNTIME swig_module_info * 
+SWIG_Tcl_GetModule(Tcl_Interp *interp) {
+  const char *data;
+  swig_module_info *ret = 0;
+  
+  /* first check if pointer already created */
+  data = Tcl_GetVar(interp, (char *)"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TCL_GLOBAL_ONLY);
+  if (data) {
+    SWIG_UnpackData(data, &ret, sizeof(swig_type_info **));
+  }
+
+  return ret;
+}
+
+SWIGRUNTIME void
+SWIG_Tcl_SetModule(Tcl_Interp *interp, swig_module_info *module) {
+  char buf[SWIG_BUFFER_SIZE];
+  char *data;
+
+  /* create a new pointer */
+  data = SWIG_PackData(buf, &module, sizeof(swig_type_info **));
+  *data = 0;
+  Tcl_SetVar(interp, (char *)"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, buf, TCL_GLOBAL_ONLY);
+}
+
+/* -----------------------------------------------------------------------------*
+ *  Object auxiliaries
+ * -----------------------------------------------------------------------------*/
+
+
+SWIGRUNTIME void
+SWIG_Tcl_ObjectDelete(ClientData clientData) {
+  swig_instance *si = (swig_instance *) clientData;
+  if (!si) return;
+  if (si->destroy && SWIG_Disown(si->thisvalue)) {
+    if (si->classptr->destructor) {
+      (si->classptr->destructor)(si->thisvalue);
+    }
+  }
+  Tcl_DecrRefCount(si->thisptr);
+  free(si);
+}
+
+/* Function to invoke object methods given an instance */
+SWIGRUNTIME int
+SWIG_Tcl_MethodCommand(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST _objv[]) {
+  char *method,   *attrname;
+  swig_instance   *inst = (swig_instance *) clientData;
+  swig_method     *meth;
+  swig_attribute  *attr;
+  Tcl_Obj         *oldarg;
+  Tcl_Obj         **objv;
+  int              rcode;
+  swig_class      *cls;
+  swig_class      *cls_stack[64];
+  int              cls_stack_bi[64];
+  int              cls_stack_top = 0;
+  int              numconf = 2;
+  int              bi;
+
+  objv = (Tcl_Obj **) _objv;
+  if (objc < 2) {
+    Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
+    return TCL_ERROR;
+  }
+  method = Tcl_GetStringFromObj(objv[1],NULL);
+  if (strcmp(method,"-acquire") == 0) {
+    inst->destroy = 1;
+    SWIG_Acquire(inst->thisvalue);
+    return TCL_OK;
+  }
+  if (strcmp(method,"-disown") == 0) {
+    if (inst->destroy) {
+      SWIG_Disown(inst->thisvalue);
+    }
+    inst->destroy = 0;
+    return TCL_OK;
+  }
+  if (strcmp(method,"-delete") == 0) {
+    Tcl_DeleteCommandFromToken(interp,inst->cmdtok);
+    return TCL_OK;
+  }
+  cls_stack[cls_stack_top] = inst->classptr;
+  cls_stack_bi[cls_stack_top] = -1;
+  while (1) {
+    Tcl_HashEntry* hashentry;
+    bi = cls_stack_bi[cls_stack_top];
+    cls = cls_stack[cls_stack_top];
+    if (bi != -1) {
+      if (!cls->bases[bi] && cls->base_names[bi]) {
+        /* lookup and cache the base class */
+	swig_type_info *info = SWIG_TypeQueryModule(cls->module, cls->module, cls->base_names[bi]);
+	if (info) cls->bases[bi] = (swig_class *) info->clientdata;
+      }
+      cls = cls->bases[bi];
+      if (cls) {
+        cls_stack_bi[cls_stack_top]++;
+        cls_stack_top++;
+        cls_stack[cls_stack_top] = cls;
+        cls_stack_bi[cls_stack_top] = -1;
+        continue;
+      }
+    }
+    if (!cls) {
+      cls_stack_top--;
+      if (cls_stack_top < 0) break;
+      else continue;
+    }
+    cls_stack_bi[cls_stack_top]++;
+
+    hashentry = Tcl_FindHashEntry(&(cls->hashtable), method);
+    if (hashentry) {
+        ClientData cd = Tcl_GetHashValue(hashentry);
+        swig_wrapper method_wrapper = (swig_wrapper)cd;
+        oldarg = objv[1];
+        objv[1] = inst->thisptr;
+        Tcl_IncrRefCount(inst->thisptr);
+        rcode = (method_wrapper)(clientData,interp,objc,objv);
+        objv[1] = oldarg;
+        Tcl_DecrRefCount(inst->thisptr);
+        return rcode;
+    }
+    /* Check class methods for a match */
+    if (strcmp(method,"cget") == 0) {
+      if (objc < 3) {
+        Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
+        return TCL_ERROR;
+      }
+      attrname = Tcl_GetStringFromObj(objv[2],NULL);
+      attr = cls->attributes;
+      while (attr && attr->name) {
+        if ((strcmp(attr->name, attrname) == 0) && (attr->getmethod)) {
+          oldarg = objv[1];
+          objv[1] = inst->thisptr;
+          Tcl_IncrRefCount(inst->thisptr);
+          rcode = (*attr->getmethod)(clientData,interp,2, objv);
+          objv[1] = oldarg;
+          Tcl_DecrRefCount(inst->thisptr);
+          return rcode;
+        }
+        attr++;
+      }
+      if (strcmp(attrname, "-this") == 0) {
+        Tcl_SetObjResult(interp, Tcl_DuplicateObj(inst->thisptr));
+        return TCL_OK;
+      }
+      if (strcmp(attrname, "-thisown") == 0) {
+        if (SWIG_Thisown(inst->thisvalue)) {
+          Tcl_SetResult(interp,(char*)"1",TCL_STATIC);
+        } else {
+          Tcl_SetResult(interp,(char*)"0",TCL_STATIC);
+        }
+        return TCL_OK;
+      }
+    } else if (strcmp(method, "configure") == 0) {
+      int i;
+      if (objc < 4) {
+        Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
+        return TCL_ERROR;
+      }
+      i = 2;
+      while (i < objc) {
+        attrname = Tcl_GetStringFromObj(objv[i],NULL);
+        attr = cls->attributes;
+        while (attr && attr->name) {
+          if ((strcmp(attr->name, attrname) == 0) && (attr->setmethod)) {
+            oldarg = objv[i];
+            objv[i] = inst->thisptr;
+            Tcl_IncrRefCount(inst->thisptr);
+            rcode = (*attr->setmethod)(clientData,interp,3, &objv[i-1]);
+            objv[i] = oldarg;
+            Tcl_DecrRefCount(inst->thisptr);
+            if (rcode != TCL_OK) return rcode;
+            numconf += 2;
+          }
+          attr++;
+        }
+        i+=2;
+      }
+    }
+  }
+  if (strcmp(method,"configure") == 0) {
+    if (numconf >= objc) {
+      return TCL_OK;
+    } else {
+      Tcl_SetResult(interp,(char *) "Invalid attribute name.", TCL_STATIC);
+      return TCL_ERROR;
+    }
+  }
+  if (strcmp(method,"cget") == 0) {
+    Tcl_SetResult(interp,(char *) "Invalid attribute name.", TCL_STATIC);
+    return TCL_ERROR;
+  }
+  Tcl_SetResult(interp, (char *) "Invalid method. Must be one of: configure cget -acquire -disown -delete", TCL_STATIC);
+  cls = inst->classptr;
+  bi = 0;
+  while (cls) {
+    meth = cls->methods;
+    while (meth && meth->name) {
+      char *cr = (char *) Tcl_GetStringResult(interp);
+      size_t meth_len = strlen(meth->name);
+      char* where = strchr(cr,':');
+      while(where) {
+        where = strstr(where, meth->name);
+        if(where) {
+          if(where[-1] == ' ' && (where[meth_len] == ' ' || where[meth_len]==0)) {
+            break;
+          } else {
+            where++;
+          }
+        }
+      }
+
+      if (!where)
+        Tcl_AppendElement(interp, (char *) meth->name);
+      meth++;
+    }
+    cls = inst->classptr->bases[bi++];
+  }
+  return TCL_ERROR;
+}
+
+/* This function takes the current result and turns it into an object command */
+SWIGRUNTIME Tcl_Obj *
+SWIG_Tcl_NewInstanceObj(Tcl_Interp *interp, void *thisvalue, swig_type_info *type, int flags) {
+  Tcl_Obj *robj = SWIG_NewPointerObj(thisvalue, type,0);
+  /* Check to see if this pointer belongs to a class or not */
+  if (thisvalue && (type->clientdata) && (interp)) {
+    Tcl_CmdInfo    ci;
+    char          *name;
+    name = Tcl_GetStringFromObj(robj,NULL);
+    if (!Tcl_GetCommandInfo(interp,name, &ci) || (flags)) {
+      swig_instance *newinst = (swig_instance *) malloc(sizeof(swig_instance));
+      newinst->thisptr = Tcl_DuplicateObj(robj);
+      Tcl_IncrRefCount(newinst->thisptr);
+      newinst->thisvalue = thisvalue;
+      newinst->classptr = (swig_class *) type->clientdata;
+      newinst->destroy = flags;
+      newinst->cmdtok = Tcl_CreateObjCommand(interp, Tcl_GetStringFromObj(robj,NULL), (swig_wrapper_func) SWIG_MethodCommand, (ClientData) newinst, (swig_delete_func) SWIG_ObjectDelete);
+      if (flags) {
+        SWIG_Acquire(thisvalue);
+      }
+    }
+  }
+  return robj;
+}
+
+/* Function to create objects */
+SWIGRUNTIME int
+SWIG_Tcl_ObjectConstructor(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
+  Tcl_Obj          *newObj = 0;
+  void             *thisvalue = 0;
+  swig_instance   *newinst = 0;
+  swig_class      *classptr = (swig_class *) clientData;
+  swig_wrapper     cons = 0;
+  char             *name = 0;
+  int               firstarg = 0;
+  int               thisarg = 0;
+  int               destroy = 1;
+
+  if (!classptr) {
+    Tcl_SetResult(interp, (char *) "swig: internal runtime error. No class object defined.", TCL_STATIC);
+    return TCL_ERROR;
+  }
+  cons = classptr->constructor;
+  if (objc > 1) {
+    char *s = Tcl_GetStringFromObj(objv[1],NULL);
+    if (strcmp(s,"-this") == 0) {
+      thisarg = 2;
+      cons = 0;
+    } else if (strcmp(s,"-args") == 0) {
+      firstarg = 1;
+    } else if (objc == 2) {
+      firstarg = 1;
+      name = s;
+    } else if (objc >= 3) {
+      char *s1;
+      name = s;
+      s1 = Tcl_GetStringFromObj(objv[2],NULL);
+      if (strcmp(s1,"-this") == 0) {
+	thisarg = 3;
+	cons = 0;
+      } else {
+	firstarg = 1;
+      }
+    }
+  }
+  if (cons) {
+    int result;
+    result = (*cons)(0, interp, objc-firstarg, &objv[firstarg]);
+    if (result != TCL_OK) {
+      return result;
+    }
+    newObj = Tcl_DuplicateObj(Tcl_GetObjResult(interp));
+    if (!name) name = Tcl_GetStringFromObj(newObj,NULL);
+  } else if (thisarg > 0) {
+    if (thisarg < objc) {
+      destroy = 0;
+      newObj = Tcl_DuplicateObj(objv[thisarg]);
+      if (!name) name = Tcl_GetStringFromObj(newObj,NULL);
+    } else {
+      Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
+      return TCL_ERROR;
+    }
+  } else {
+    Tcl_SetResult(interp, (char *) "No constructor available.", TCL_STATIC);
+    return TCL_ERROR;
+  }
+  if (SWIG_Tcl_ConvertPtr(interp,newObj, (void **) &thisvalue, *(classptr->type), 0) != SWIG_OK) {
+    Tcl_DecrRefCount(newObj);
+    return TCL_ERROR;
+  }
+  newinst = (swig_instance *) malloc(sizeof(swig_instance));
+  newinst->thisptr = newObj;
+  Tcl_IncrRefCount(newObj);
+  newinst->thisvalue = thisvalue;
+  newinst->classptr = classptr;
+  newinst->destroy = destroy;
+  if (destroy) {
+    SWIG_Acquire(thisvalue);
+  }
+  newinst->cmdtok = Tcl_CreateObjCommand(interp,name, (swig_wrapper) SWIG_MethodCommand, (ClientData) newinst, (swig_delete_func) SWIG_ObjectDelete);
+  return TCL_OK;
+}
+
+/* -----------------------------------------------------------------------------*
+ *   Get arguments 
+ * -----------------------------------------------------------------------------*/
+SWIGRUNTIME int
+SWIG_Tcl_GetArgs(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], const char *fmt, ...) {
+  int        argno = 0, opt = 0;
+  long       tempi;
+  double     tempd;
+  const char *c;
+  va_list    ap;
+  void      *vptr;
+  Tcl_Obj   *obj = 0;
+  swig_type_info *ty;
+
+  va_start(ap,fmt);
+  for (c = fmt; (*c && (*c != ':') && (*c != ';')); c++,argno++) {
+    if (*c == '|') {
+      opt = 1;
+      c++;
+    }
+    if (argno >= (objc-1)) {
+      if (!opt) {
+        Tcl_SetResult(interp, (char *) "Wrong number of arguments ", TCL_STATIC);
+        goto argerror;
+      } else {
+        va_end(ap);
+        return TCL_OK;
+      }
+    }
+
+    vptr = va_arg(ap,void *);
+    if (vptr) {
+      if (isupper(*c)) {
+        obj = SWIG_Tcl_GetConstantObj(Tcl_GetStringFromObj(objv[argno+1],0));
+        if (!obj) obj = objv[argno+1];
+      } else {
+        obj = objv[argno+1];
+      }
+      switch(*c) {
+      case 'i': case 'I':
+      case 'l': case 'L':
+      case 'h': case 'H':
+      case 'b': case 'B':
+        if (Tcl_GetLongFromObj(interp,obj,&tempi) != TCL_OK) goto argerror;
+        if ((*c == 'i') || (*c == 'I')) *((int *)vptr) = (int)tempi;
+        else if ((*c == 'l') || (*c == 'L')) *((long *)vptr) = (long)tempi;
+        else if ((*c == 'h') || (*c == 'H')) *((short*)vptr) = (short)tempi;
+        else if ((*c == 'b') || (*c == 'B')) *((unsigned char *)vptr) = (unsigned char)tempi;
+        break;
+      case 'f': case 'F':
+      case 'd': case 'D':
+        if (Tcl_GetDoubleFromObj(interp,obj,&tempd) != TCL_OK) goto argerror;
+        if ((*c == 'f') || (*c == 'F')) *((float *) vptr) = (float)tempd;
+        else if ((*c == 'd') || (*c == 'D')) *((double*) vptr) = tempd;
+        break;
+      case 's': case 'S':
+        if (*(c+1) == '#') {
+          int *vlptr = (int *) va_arg(ap, void *);
+          *((char **) vptr) = Tcl_GetStringFromObj(obj, vlptr);
+          c++;
+        } else {
+          *((char **)vptr) = Tcl_GetStringFromObj(obj,NULL);
+        }
+        break;
+      case 'c': case 'C':
+        *((char *)vptr) = *(Tcl_GetStringFromObj(obj,NULL));
+        break;
+      case 'p': case 'P':
+        ty = (swig_type_info *) va_arg(ap, void *);
+        if (SWIG_Tcl_ConvertPtr(interp, obj, (void **) vptr, ty, 0) != SWIG_OK) goto argerror;
+        break;
+      case 'o': case 'O':
+        *((Tcl_Obj **)vptr) = objv[argno+1];
+        break;
+      default:
+        break;
+      }
+    }
+  }
+
+  if ((*c != ';') && ((objc-1) > argno)) {
+    Tcl_SetResult(interp, (char *) "Wrong # args.", TCL_STATIC);
+    goto argerror;
+  }
+  va_end(ap);
+  return TCL_OK;
+
+ argerror:
+  {
+    char temp[32];
+    sprintf(temp,"%d", argno+1);
+    c = strchr(fmt,':');
+    if (!c) c = strchr(fmt,';');
+    if (!c) c = (char *)"";
+    Tcl_AppendResult(interp,c," argument ", temp, NULL);
+    va_end(ap);
+    return TCL_ERROR;
+  }
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/share/swig/2.0.11/tcl/tclruntime.swg b/share/swig/3.0.12/tcl/tclruntime.swg
index bb4edd7..bb4edd7 100644
--- a/share/swig/2.0.11/tcl/tclruntime.swg
+++ b/share/swig/3.0.12/tcl/tclruntime.swg
diff --git a/share/swig/2.0.11/tcl/tclsh.i b/share/swig/3.0.12/tcl/tclsh.i
index 160ba8d..160ba8d 100644
--- a/share/swig/2.0.11/tcl/tclsh.i
+++ b/share/swig/3.0.12/tcl/tclsh.i
diff --git a/share/swig/2.0.11/tcl/tclstrings.swg b/share/swig/3.0.12/tcl/tclstrings.swg
index 540d627..540d627 100644
--- a/share/swig/2.0.11/tcl/tclstrings.swg
+++ b/share/swig/3.0.12/tcl/tclstrings.swg
diff --git a/share/swig/3.0.12/tcl/tcltypemaps.swg b/share/swig/3.0.12/tcl/tcltypemaps.swg
new file mode 100644
index 0000000..ad31bcf
--- /dev/null
+++ b/share/swig/3.0.12/tcl/tcltypemaps.swg
@@ -0,0 +1,91 @@
+/* ------------------------------------------------------------
+ *  Typemap specializations for Tcl
+ * ------------------------------------------------------------ */
+
+/* ------------------------------------------------------------
+ *  Fragment section
+ * ------------------------------------------------------------ */
+
+/*
+  In Tcl we need to pass the interp value, so we define the decl/call
+  macros as needed.
+*/
+
+#define SWIG_AS_DECL_ARGS SWIG_TCL_DECL_ARGS_2
+#define SWIG_AS_CALL_ARGS SWIG_TCL_CALL_ARGS_2
+
+
+/* Include fundamental fragment definitions */
+%include <typemaps/fragments.swg>
+
+/* Look for user fragments file. */
+%include <tclfragments.swg>
+
+/* Tcl fragments for primitive types */
+%include <tclprimtypes.swg>
+
+/* Tcl fragments for char* strings */
+%include <tclstrings.swg>
+
+
+/* ------------------------------------------------------------
+ *  Unified typemap section
+ * ------------------------------------------------------------ */
+
+/* No director support in Tcl */
+#ifdef SWIG_DIRECTOR_TYPEMAPS
+#undef SWIG_DIRECTOR_TYPEMAPS
+#endif
+
+
+/* Tcl types */
+#define SWIG_Object                      Tcl_Obj *
+
+/* Overload of the output/constant/exception handling */
+
+/* output */
+#define %set_output(obj)                 Tcl_SetObjResult(interp,obj)
+
+/* append output */
+#define %append_output(obj)              Tcl_ListObjAppendElement(interp,Tcl_GetObjResult(interp),obj)
+
+/* set constant */
+#define SWIG_SetConstant(name, obj)      SWIG_Tcl_SetConstantObj(interp, name, obj)
+
+/* raise */
+#define SWIG_Raise(obj,type,desc)        SWIG_Tcl_SetErrorObj(interp,type,obj)
+
+
+/* Include the unified typemap library */
+%include <typemaps/swigtypemaps.swg>
+
+
+/* ------------------------------------------------------------
+ *  Tcl extra typemaps / typemap overrides
+ * ------------------------------------------------------------ */
+
+#if 1
+// Old 1.3.25 typemaps needed to avoid premature object deletion
+%typemap(out,noblock=1) SWIGTYPE *INSTANCE, SWIGTYPE &INSTANCE, SWIGTYPE &&INSTANCE, SWIGTYPE INSTANCE[] {
+  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( %as_voidptr($1), $1_descriptor,0));
+}
+
+%typemap(out) SWIGTYPE *DYNAMIC, SWIGTYPE &DYNAMIC {
+  swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor,%as_voidptrptr(&$1));
+  Tcl_SetObjResult(interp,SWIG_NewInstanceObj(%as_voidptr($1), ty,0));
+}
+
+#endif
+
+%typemap(throws,noblock=1) SWIGTYPE CLASS {
+  SWIG_set_result(SWIG_NewInstanceObj(%as_voidptr(SWIG_new_copy($1, $1_ltype)), $&1_descriptor, 1));
+  SWIG_fail;
+}
+
+%typemap(out)    SWIGTYPE    =  SWIGTYPE INSTANCE;
+%typemap(out)    SWIGTYPE *  =  SWIGTYPE *INSTANCE;
+%typemap(out)    SWIGTYPE *const  =  SWIGTYPE *;
+%typemap(out)    SWIGTYPE &  =  SWIGTYPE &INSTANCE;
+%typemap(out)    SWIGTYPE && =  SWIGTYPE &&INSTANCE;
+%typemap(out)    SWIGTYPE [] =  SWIGTYPE INSTANCE[];
+%typemap(varout) SWIGTYPE    =  SWIGTYPE INSTANCE;
diff --git a/share/swig/2.0.11/tcl/tcluserdir.swg b/share/swig/3.0.12/tcl/tcluserdir.swg
index d5b41fb..d5b41fb 100644
--- a/share/swig/2.0.11/tcl/tcluserdir.swg
+++ b/share/swig/3.0.12/tcl/tcluserdir.swg
diff --git a/share/swig/2.0.11/tcl/tclwstrings.swg b/share/swig/3.0.12/tcl/tclwstrings.swg
index b3b682e..b3b682e 100644
--- a/share/swig/2.0.11/tcl/tclwstrings.swg
+++ b/share/swig/3.0.12/tcl/tclwstrings.swg
diff --git a/share/swig/2.0.11/tcl/typemaps.i b/share/swig/3.0.12/tcl/typemaps.i
index 04a5c78..04a5c78 100644
--- a/share/swig/2.0.11/tcl/typemaps.i
+++ b/share/swig/3.0.12/tcl/typemaps.i
diff --git a/share/swig/2.0.11/tcl/wish.i b/share/swig/3.0.12/tcl/wish.i
index 260032a..260032a 100644
--- a/share/swig/2.0.11/tcl/wish.i
+++ b/share/swig/3.0.12/tcl/wish.i
diff --git a/share/swig/3.0.12/typemaps/attribute.swg b/share/swig/3.0.12/typemaps/attribute.swg
new file mode 100644
index 0000000..9881139
--- /dev/null
+++ b/share/swig/3.0.12/typemaps/attribute.swg
@@ -0,0 +1,286 @@
+/* -----------------------------------------------------------------------------
+ * attribute.swg
+ *
+ * Attribute implementation
+ * ----------------------------------------------------------------------------- */
+
+/*
+  The following macros convert a pair of set/get methods
+  into a "native" attribute.
+
+  Use %attribute when you have a pair of get/set methods to a primitive type
+  like in:
+
+      %attribute(A, int, a, get_a, set_a);
+
+      struct A
+      {
+        int get_a() const;
+        void set_a(int aa);
+      };
+
+  If you don't provide a 'set' method, a 'read-only' attribute
+  is generated, ie, like in:
+
+      %attribute(A, int, c, get_c);
+
+  Use %attributeref when you have const/non-const reference access methods
+  for primitive types or class/structs, like in:
+
+      %attributeref(A, int, b);
+
+      struct A
+      {
+        const int& b() const;
+        int& b();
+      };
+
+      %attributeref(B, int, c);
+
+      struct B
+      {
+        int& c();
+      };
+
+  You can also use
+
+      %attributeref(Class, AttributeType, AttributeName, AccessorMethod)
+
+  if the internal C++ reference methods have a different name from the
+  attribute you want, so
+
+      %attributeref(B, int, d, c);
+
+  is the same as the last example, but instead of the attribute 'c' being
+  called 'c', it is called 'd'.
+
+  Now you can use the attributes like so:
+
+      x = A()
+      x.a = 3        # calls A::set_a
+      print x.a      # calls A::get_a
+
+      x.b = 3        # calls A::b()
+      print x.b      # calls A::b() const
+
+  Use %attribute2 instead of %attribute to indicate that reference-pointer
+  translation is required. You use %attribute2 instead of %attribute in
+  cases like this:
+ 
+  %attribute2(MyClass, MyFoo, Foo, GetFoo, SetFoo);
+  %inline %{
+    struct MyFoo { 
+      int x;
+    };
+    class MyClass {
+      MyFoo foo;
+    public:
+      MyFoo& GetFoo() { return foo; }
+      void SetFoo(const MyFoo& other) { foo = other; }
+    };
+  %}
+
+  Here, the data type of the property is a wrapped type (MyFoo) and on the
+  C++ side it is passed by reference. The problem is that the SWIG wrapper will
+  pass around a pointer (MyFoo *) which is not compatible with the reference
+  type of the accessors (MyFoo &). Therefore, if you use %attribute, you'll get
+  an error from your C/C++ compiler. %attribute2 translates between a pointer
+  and a reference to eliminate the error. In case you're confused, let's make it
+  simple: just use %attribute at first, but if the C/C++ compiler gives an error
+  while compiling the wrapper, try %attribute2 instead.
+
+  NOTE: remember that if the type contains commas, such as 'std::pair<int,int>',
+  you need to use the macro like:
+
+  %attributeref(A, %arg(std::pair<int,int>), pval);
+
+  where %arg() 'normalizes' the type to be understood as a single
+  argument, otherwise the macro will get confused by the comma.
+
+  The %attributeval is the same as %attribute, but should be used when the type
+  is a class/struct (ie a non-primitive type) and when the get and set methods 
+  return/pass by value. The following is very similar to the above example, but 
+  note that the access is by value rather than reference.
+
+    %attributeval(MyClassVal, MyFoo, ReadWriteFoo, GetFoo, SetFoo);
+    %attributeval(MyClassVal, MyFoo, ReadOnlyFoo, GetFoo);
+    %inline %{
+      class MyClassVal {
+	MyFoo foo;
+      public:
+	MyFoo GetFoo() { return foo; }
+	void SetFoo(MyFoo other) { foo = other; }
+      };
+    %} 
+
+  The %attributestring is the same as %attributeval, but should be used for string
+  class types, which are unusual as they are a class on the C++ side, but normally an
+  immutable/primitive type in the target language. Example usage for std::string:
+
+    %include <std_string.i>
+    %attributestring(MyStringyClass, std::string, ReadWriteString, GetString, SetString);
+    %attributestring(MyStringyClass, std::string, ReadOnlyString, GetString);
+    %inline %{
+      class MyStringyClass {
+	std::string str;
+      public:
+	MyStringyClass(const std::string &val) : str(val) {}
+	std::string GetString() { return str; }
+	void SetString(std::string other) { str = other; }
+      };
+    %} 
+
+  The %attributestring also works for class types that have %naturalvar turned
+  on and so is also useful for shared_ptr which has %naturalvar turned on in %shared_ptr.
+
+*/
+
+//
+// Define SWIG_ATTRIBUTE_TEMPLATE if you want to use templates instead of macros for the C++ get and set wrapper methods
+// Does not always generate compilable code, use at your peril!
+//
+//#define SWIG_ATTRIBUTE_TEMPLATE
+
+%define %attribute_custom(Class, AttributeType, AttributeName, GetMethod, SetMethod, GetMethodCall, SetMethodCall)
+  %ignore Class::GetMethod();
+  %ignore Class::GetMethod() const;
+  #if #SetMethod != #AttributeName
+    %ignore Class::SetMethod;
+  #endif
+  %extend Class {
+    AttributeType AttributeName;
+  }
+#if defined(__cplusplus) && defined(SWIG_ATTRIBUTE_TEMPLATE)
+  %{
+    template < class C > inline AttributeType %mangle(Class) ##_## AttributeName ## _get(const C* self_) {
+      return GetMethodCall;
+    }
+    template < class C > inline AttributeType %mangle(Class) ##_## AttributeName ## _get(C* self_) {
+      return GetMethodCall;
+    }
+    template < class C > inline void %mangle(Class) ##_## AttributeName ## _set(C* self_, AttributeType val_) {
+      SetMethodCall;
+    }
+  %}
+#else
+  %{
+    #define %mangle(Class) ##_## AttributeName ## _get(self_) GetMethodCall
+    #define %mangle(Class) ##_## AttributeName ## _set(self_, val_) SetMethodCall
+  %}
+#endif
+%enddef
+
+%define %attribute_readonly(Class, AttributeType, AttributeName, GetMethod, GetMethodCall)
+  %ignore Class::GetMethod();
+  %ignore Class::GetMethod() const;
+  %immutable Class::AttributeName;
+  %extend Class {
+    AttributeType AttributeName;
+  }
+#if defined(__cplusplus) && defined(SWIG_ATTRIBUTE_TEMPLATE)
+  %{
+    template < class C > inline AttributeType %mangle(Class) ##_## AttributeName ## _get(const C* self_) {
+      return GetMethodCall;
+    }
+    template < class C > inline AttributeType %mangle(Class) ##_## AttributeName ## _get(C* self_) {
+      return GetMethodCall;
+    }
+  %}
+#else
+  %{
+    #define %mangle(Class) ##_## AttributeName ## _get(self_) GetMethodCall
+  %}
+#endif
+%enddef
+
+
+// User macros
+
+%define %attribute(Class, AttributeType, AttributeName, GetMethod, SetMethod...)
+  #if #SetMethod != ""
+    %attribute_custom(%arg(Class), %arg(AttributeType), AttributeName, GetMethod, SetMethod, self_->GetMethod(), self_->SetMethod(val_))
+  #else
+    %attribute_readonly(%arg(Class), %arg(AttributeType), AttributeName, GetMethod, self_->GetMethod())
+  #endif
+%enddef
+
+%define %attribute2(Class, AttributeType, AttributeName, GetMethod, SetMethod...)
+  #if #SetMethod != ""
+    %attribute_custom(%arg(Class), %arg(AttributeType), AttributeName, GetMethod, SetMethod, &self_->GetMethod(), self_->SetMethod(*val_))
+  #else
+    %attribute_readonly(%arg(Class), %arg(AttributeType), AttributeName, GetMethod, &self_->GetMethod())
+  #endif
+%enddef
+
+%define %attributeref(Class, AttributeType, AttributeName, AccessorMethod...)
+  #if #AccessorMethod != ""
+    %attribute_custom(%arg(Class), %arg(AttributeType), AttributeName, AccessorMethod, AccessorMethod, self_->AccessorMethod(), self_->AccessorMethod() = val_)
+  #else
+    %attribute_custom(%arg(Class), %arg(AttributeType), AttributeName, AttributeName, AttributeName, self_->AttributeName(), self_->AttributeName() = val_)
+  #endif
+%enddef
+
+%define %attribute2ref(Class, AttributeType, AttributeName, AccessorMethod...)
+  #if #AccessorMethod != ""
+    %attribute_custom(%arg(Class), %arg(AttributeType), AttributeName, AccessorMethod, AccessorMethod, &self_->AccessorMethod(), self_->AccessorMethod() = *val_)
+  #else
+    %attribute_custom(%arg(Class), %arg(AttributeType), AccessorName, AccessorName, AccessorName, &self_->AccessorName(), self_->AccessorName() = *val_)
+  #endif
+%enddef
+
+// deprecated (same as %attributeref, but there is an argument order inconsistency)
+%define %attribute_ref(Class, AttributeType, AccessorMethod, AttributeName...)
+  #if #AttributeName != ""
+    %attribute_custom(%arg(Class), %arg(AttributeType), AttributeName, AccessorMethod, AccessorMethod, self_->AccessorMethod(), self_->AccessorMethod() = val_)
+  #else
+    %attribute_custom(%arg(Class), %arg(AttributeType), AccessorMethod, AccessorMethod, AccessorMethod, self_->AccessorMethod(), self_->AccessorMethod() = val_)
+  #endif
+%enddef
+
+
+%define %attributeval(Class, AttributeType, AttributeName, GetMethod, SetMethod...)
+  %{
+    #define %mangle(Class) ##_## AttributeName ## _get(self_) new AttributeType(self_->GetMethod())
+  %}
+  #if #SetMethod != ""
+    %{
+      #define %mangle(Class) ##_## AttributeName ## _set(self_, val_) self_->SetMethod(*val_)
+    %}
+    #if #SetMethod != #AttributeName
+      %ignore Class::SetMethod;
+    #endif
+  #else
+    %immutable Class::AttributeName;
+  #endif
+  %ignore Class::GetMethod();
+  %ignore Class::GetMethod() const;
+  %newobject Class::AttributeName;
+  %extend Class {
+    AttributeType AttributeName;
+  }
+%enddef
+
+
+%define %attributestring(Class, AttributeType, AttributeName, GetMethod, SetMethod...)
+  %{
+    #define %mangle(Class) ##_## AttributeName ## _get(self_) *new AttributeType(self_->GetMethod())
+  %}
+  #if #SetMethod != ""
+    %{
+      #define %mangle(Class) ##_## AttributeName ## _set(self_, val_) self_->SetMethod(val_)
+    %}
+    #if #SetMethod != #AttributeName
+      %ignore Class::SetMethod;
+    #endif
+  #else
+    %immutable Class::AttributeName;
+  #endif
+  %ignore Class::GetMethod();
+  %ignore Class::GetMethod() const;
+  %newobject Class::AttributeName;
+  %typemap(newfree) const AttributeType &AttributeName "delete $1;"
+  %extend Class {
+    AttributeType AttributeName;
+  }
+%enddef
+
diff --git a/share/swig/2.0.11/typemaps/carrays.swg b/share/swig/3.0.12/typemaps/carrays.swg
index 462d60b..462d60b 100644
--- a/share/swig/2.0.11/typemaps/carrays.swg
+++ b/share/swig/3.0.12/typemaps/carrays.swg
diff --git a/share/swig/2.0.11/typemaps/cdata.swg b/share/swig/3.0.12/typemaps/cdata.swg
index 8597b7b..8597b7b 100644
--- a/share/swig/2.0.11/typemaps/cdata.swg
+++ b/share/swig/3.0.12/typemaps/cdata.swg
diff --git a/share/swig/2.0.11/typemaps/cmalloc.swg b/share/swig/3.0.12/typemaps/cmalloc.swg
index 45a6ab9..45a6ab9 100644
--- a/share/swig/2.0.11/typemaps/cmalloc.swg
+++ b/share/swig/3.0.12/typemaps/cmalloc.swg
diff --git a/share/swig/2.0.11/typemaps/cpointer.swg b/share/swig/3.0.12/typemaps/cpointer.swg
index 94bbbd6..94bbbd6 100644
--- a/share/swig/2.0.11/typemaps/cpointer.swg
+++ b/share/swig/3.0.12/typemaps/cpointer.swg
diff --git a/share/swig/2.0.11/typemaps/cstring.swg b/share/swig/3.0.12/typemaps/cstring.swg
index e774c43..e774c43 100644
--- a/share/swig/2.0.11/typemaps/cstring.swg
+++ b/share/swig/3.0.12/typemaps/cstring.swg
diff --git a/share/swig/3.0.12/typemaps/cstrings.swg b/share/swig/3.0.12/typemaps/cstrings.swg
new file mode 100644
index 0000000..0aca611
--- /dev/null
+++ b/share/swig/3.0.12/typemaps/cstrings.swg
@@ -0,0 +1,288 @@
+/* -----------------------------------------------------------------------------
+ * cstrings.swg
+ *
+ * This file provides typemaps and macros for dealing with various forms
+ * of C character string handling.   The primary use of this module
+ * is in returning character data that has been allocated or changed in
+ * some way.
+ * ----------------------------------------------------------------------------- */
+
+%define %typemaps_cstring(Name, Char,
+			  SWIG_AsCharPtr,
+			  SWIG_AsCharPtrAndSize,
+			  SWIG_FromCharPtr,
+			  SWIG_FromCharPtrAndSize)
+
+
+/* %cstring_input_binary(TYPEMAP, SIZE)
+ * 
+ * Macro makes a function accept binary string data along with
+ * a size.  For example:
+ *
+ *     %cstring_input_binary(Char *buff, int size);
+ *     void foo(Char *buff, int size) {
+ *     }
+ *
+ */
+
+%define Name ## _input_binary(TYPEMAP, SIZE)                   
+%typemap(in,noblock=1,fragment=#SWIG_AsCharPtrAndSize) (TYPEMAP, SIZE) 
+  (int res, Char *buf = 0, size_t size = 0, int alloc = 0)  {
+  res = SWIG_AsCharPtrAndSize($input, &buf, &size, &alloc);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "(TYPEMAP, SIZE)", $symname, $argnum);
+  }
+  $1 = ($1_ltype) buf;					       
+  $2 = ($2_ltype) size - 1;				       
+}
+%typemap(freearg,noblock=1,match="in") (TYPEMAP, SIZE) {
+  if (alloc$argnum == SWIG_NEWOBJ) %delete_array(buf$argnum);
+}
+%enddef								
+
+
+
+/*
+ * %cstring_bounded_output(TYPEMAP, MAX)
+ *
+ * This macro is used to return a NULL-terminated output string of
+ * some maximum length.  For example:
+ *
+ *     %cstring_bounded_output(Char *outx, 512);
+ *     void foo(Char *outx) {
+ *         sprintf(outx,"blah blah\n");
+ *     }
+ *
+ */
+
+%define Name ## _bounded_output(TYPEMAP,MAX)        
+%typemap(in,noblock=1,numinputs=0) TYPEMAP (Char temp[MAX+1])  {
+  $1 = ($1_ltype) temp;
+}
+%typemap(freearg,match="in") TYPEMAP "";
+%typemap(argout,noblock=1,fragment= #SWIG_FromCharPtr ) TYPEMAP {
+  $1[MAX] = 0;  
+  %append_output(SWIG_FromCharPtr($1));
+}
+%enddef
+
+
+
+/*
+ * %cstring_chunk_output(TYPEMAP, SIZE)
+ *
+ * This macro is used to return a chunk of binary string data.
+ * Embedded NULLs are okay.  For example:
+ *
+ *     %cstring_chunk_output(Char *outx, 512);
+ *     void foo(Char *outx) {
+ *         memmove(outx, somedata, 512);
+ *     }
+ *
+ */
+
+%define Name ## _chunk_output(TYPEMAP,SIZE)           
+%typemap(in,noblock=1,numinputs=0) TYPEMAP(Char temp[SIZE]) {
+  $1 = ($1_ltype) temp;
+}
+%typemap(freearg,match="in") TYPEMAP "";
+%typemap(argout,noblock=1,fragment= #SWIG_FromCharPtrAndSize) TYPEMAP {
+  %append_output(SWIG_FromCharPtrAndSize($1,SIZE));
+}
+%enddef
+
+
+
+/*
+ * %cstring_bounded_mutable(TYPEMAP, SIZE)
+ *
+ * This macro is used to wrap a string that's going to mutate.
+ *
+ *     %cstring_bounded_mutable(Char *in, 512);
+ *     void foo(in *x) {
+ *         while (*x) {
+ *            *x = toupper(*x);
+ *            x++;
+ *         }
+ *     }
+ *
+ */
+
+
+%define Name ## _bounded_mutable(TYPEMAP,MAX)                              
+%typemap(in,noblock=1,fragment=#SWIG_AsCharPtrAndSize) TYPEMAP 
+  (int res,Char temp[MAX+1], Char *t = 0, size_t n = 0, int alloc = 0) {  
+  res = SWIG_AsCharPtrAndSize($input, &t, &n, &alloc);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "TYPEMAP", $symname, $argnum);
+  }
+  if ( n > (size_t) MAX ) n = (size_t) MAX;
+  memcpy(temp, t, sizeof(Char)*n);
+  if (alloc == SWIG_NEWOBJ) %delete_array(t);
+  temp[n - 1] = 0;                                                             
+  $1 = ($1_ltype) temp;                                                    
+}
+%typemap(freearg,match="in") TYPEMAP "";
+%typemap(argout,noblock=1,fragment=#SWIG_FromCharPtr) TYPEMAP {
+  $1[MAX] = 0;
+  %append_output(SWIG_FromCharPtr($1));
+}
+%enddef
+
+
+/*
+ * %cstring_mutable(TYPEMAP [, expansion])
+ *
+ * This macro is used to wrap a string that will mutate in place.
+ * It may change size up to a user-defined expansion. 
+ *
+ *     %cstring_mutable(Char *in);
+ *     void foo(in *x) {
+ *         while (*x) {
+ *            *x = toupper(*x);
+ *            x++;
+ *         }
+ *     }
+ *
+ */
+
+%define Name ## _mutable(TYPEMAP,EXP...)                  
+%typemap(in,noblock=1,fragment=#SWIG_AsCharPtrAndSize) TYPEMAP (int res, Char *t = 0, size_t n = 0, int alloc = 0, size_t expansion = 0) {
+#if #EXP != ""
+  expansion += EXP;
+#endif
+  res = SWIG_AsCharPtrAndSize($input, &t, &n, &alloc);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "TYPEMAP", $symname, $argnum);
+  }
+  $1 = %new_array(n+expansion, $*1_ltype);          
+  memcpy($1,t,sizeof(Char)*n);
+  if (alloc == SWIG_NEWOBJ) %delete_array(t);
+  $1[n-1] = 0;
+}
+%typemap(freearg,match="in") TYPEMAP "";
+%typemap(argout,noblock=1,fragment=#SWIG_FromCharPtr) TYPEMAP { 
+  %append_output(SWIG_FromCharPtr($1));
+  %delete_array($1);                                  
+}
+%enddef
+
+
+/*
+ * %cstring_output_maxsize(TYPEMAP, SIZE)
+ *
+ * This macro returns data in a string of some user-defined size.
+ *
+ *     %cstring_output_maxsize(Char *outx, int max) {
+ *     void foo(Char *outx, int max) {
+ *         sprintf(outx,"blah blah\n");
+ *     }
+ */
+
+%define Name ## _output_maxsize(TYPEMAP, SIZE)                       
+%typemap(in,noblock=1,fragment=SWIG_AsVal_frag(size_t)) (TYPEMAP, SIZE) (int res, size_t size, Char *buff = 0) {   
+  res = SWIG_AsVal(size_t)($input, &size);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "(TYPEMAP, SIZE)", $symname, $argnum);
+  }
+  buff= %new_array(size+1, Char);
+  $2 = %numeric_cast(size, $2_ltype);
+  $1 = %static_cast(buff, $1_ltype);
+}
+%typemap(freearg,noblock=1,match="in") (TYPEMAP,SIZE) {
+  if (buff$argnum) %delete_array(buff$argnum);
+} 
+%typemap(argout,noblock=1,fragment=#SWIG_FromCharPtr) (TYPEMAP,SIZE) { 
+  %append_output(SWIG_FromCharPtr($1));
+}
+%enddef
+
+/*
+ * %cstring_output_withsize(TYPEMAP, SIZE)
+ *
+ * This macro is used to return Character data along with a size
+ * parameter.
+ *
+ *     %cstring_output_withsize(Char *outx, int *max) {
+ *     void foo(Char *outx, int *max) {
+ *         sprintf(outx,"blah blah\n");
+ *         *max = strlen(outx);  
+ *     }
+ */
+
+%define Name ## _output_withsize(TYPEMAP, SIZE)                        
+%typemap(in,noblock=1,fragment=SWIG_AsVal_frag(size_t)) (TYPEMAP, SIZE) (int res, size_t n, Char *buff = 0, $*2_ltype size) {    
+  res = SWIG_AsVal(size_t)($input, &n);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "(TYPEMAP, SIZE)", $symname, $argnum);
+  }
+  buff= %new_array(n+1, Char);
+  $1 = %static_cast(buff, $1_ltype);
+  size = %numeric_cast(n,$*2_ltype);
+  $2 = &size;
+}								       
+%typemap(freearg,noblock=1,match="in")(TYPEMAP,SIZE) {
+  if (buff$argnum) %delete_array(buff$argnum);
+} 
+%typemap(argout,noblock=1,fragment=#SWIG_FromCharPtrAndSize) (TYPEMAP,SIZE) { 
+  %append_output(SWIG_FromCharPtrAndSize($1,*$2));
+}
+%enddef
+
+
+/*
+ * %cstring_output_allocate(TYPEMAP, RELEASE)
+ *
+ * This macro is used to return Character data that was
+ * allocated with new or malloc.
+ *
+ *     %cstring_output_allocate(Char **outx, free($1));
+ *     void foo(Char **outx) {
+ *         *outx = (Char *) malloc(512);
+ *         sprintf(outx,"blah blah\n");
+ *     }
+ */
+ 
+%define Name ## _output_allocate(TYPEMAP, RELEASE)           
+%typemap(in,noblock=1,numinputs=0) TYPEMAP($*1_ltype temp = 0) {
+  $1 = &temp;
+}
+%typemap(freearg,match="in") TYPEMAP "";
+%typemap(argout,noblock=1,fragment=#SWIG_FromCharPtr) TYPEMAP { 
+  if (*$1) {
+    %append_output(SWIG_FromCharPtr(*$1));
+    RELEASE;					  	     
+  }					  	     
+}							     
+%enddef
+
+
+/*
+ * %cstring_output_allocate_size(TYPEMAP, SIZE, RELEASE)
+ *
+ * This macro is used to return Character data that was
+ * allocated with new or malloc.
+ *
+ *     %cstring_output_allocate_size(Char **outx, int *sz, free($1));
+ *     void foo(Char **outx, int *sz) {
+ *         *outx = (Char *) malloc(512);
+ *         sprintf(outx,"blah blah\n");
+ *         *sz = strlen(outx);
+ *     }
+ */
+
+%define Name ## _output_allocate_size(TYPEMAP, SIZE, RELEASE)
+%typemap(in,noblock=1,numinputs=0) (TYPEMAP, SIZE) ($*1_ltype temp = 0, $*2_ltype tempn) {
+  $1 = &temp; $2 = &tempn;
+}
+%typemap(freearg,match="in") (TYPEMAP,SIZE) "";
+%typemap(argout,noblock=1,fragment=#SWIG_FromCharPtrAndSize)(TYPEMAP,SIZE) {   
+  if (*$1) {
+    %append_output(SWIG_FromCharPtrAndSize(*$1,*$2));
+    RELEASE;
+  }
+}
+%enddef
+
+%enddef
+
diff --git a/share/swig/2.0.11/typemaps/cwstring.swg b/share/swig/3.0.12/typemaps/cwstring.swg
index 933f9a3..933f9a3 100644
--- a/share/swig/2.0.11/typemaps/cwstring.swg
+++ b/share/swig/3.0.12/typemaps/cwstring.swg
diff --git a/share/swig/3.0.12/typemaps/enumint.swg b/share/swig/3.0.12/typemaps/enumint.swg
new file mode 100644
index 0000000..d048bb6
--- /dev/null
+++ b/share/swig/3.0.12/typemaps/enumint.swg
@@ -0,0 +1,39 @@
+/* ------------------------------------------------------------
+ *  Enums mapped as integer values
+ * ------------------------------------------------------------ */
+
+%apply int { enum SWIGTYPE };
+%apply const int& { const enum SWIGTYPE & };
+%apply const int& { const enum SWIGTYPE && };
+
+%typemap(in,fragment=SWIG_AsVal_frag(int),noblock=1) const enum SWIGTYPE & (int val, int ecode, $basetype temp) {  
+  ecode = SWIG_AsVal(int)($input, &val);
+  if (!SWIG_IsOK(ecode)) {
+    %argument_fail(ecode, "$type", $symname, $argnum);
+  } else {
+    temp = %static_cast(val,$basetype);
+    $1 = &temp;
+  }
+}
+
+%typemap(in,fragment=SWIG_AsVal_frag(int),noblock=1) const enum SWIGTYPE && (int val, int ecode, $basetype temp) {  
+  ecode = SWIG_AsVal(int)($input, &val);
+  if (!SWIG_IsOK(ecode)) {
+    %argument_fail(ecode, "$type", $symname, $argnum);
+  } else {
+    temp = %static_cast(val,$basetype);
+    $1 = &temp;
+  }
+}
+
+%typemap(varin,fragment=SWIG_AsVal_frag(int),noblock=1) enum SWIGTYPE {
+  if (sizeof(int) != sizeof($1)) {
+    %variable_fail(SWIG_AttributeError,"$type", "arch, read-only $name");
+  }  else {
+    int ecode = SWIG_AsVal(int)($input, %reinterpret_cast(&$1,int*));
+    if (!SWIG_IsOK(ecode)) {
+      %variable_fail(ecode, "$type", "$name");
+    }
+  }
+}
+
diff --git a/share/swig/3.0.12/typemaps/exception.swg b/share/swig/3.0.12/typemaps/exception.swg
new file mode 100644
index 0000000..b60a329
--- /dev/null
+++ b/share/swig/3.0.12/typemaps/exception.swg
@@ -0,0 +1,86 @@
+/* -----------------------------------------------------------------------------
+ * exceptions.swg
+ *
+ * This SWIG library file provides language independent exception handling
+ * ----------------------------------------------------------------------------- */
+
+%include <typemaps/swigmacros.swg>
+
+
+/* macros for error manipulation */
+#define %nullref_fmt()                     "invalid null reference "		   
+#define %varfail_fmt(_type,_name)          "in variable '"`_name`"' of type '"`_type`"'"
+#ifndef %argfail_fmt
+#define %argfail_fmt(_type,_name,_argn)    "in method '" `_name` "', argument " `_argn`" of type '" `_type`"'"
+#endif
+#define %outfail_fmt(_type)                "in output value of type '"_type"'"
+#ifndef	%argnullref_fmt
+#define %argnullref_fmt(_type,_name,_argn) %nullref_fmt() %argfail_fmt(_type, _name, _argn)
+#endif  
+#define %varnullref_fmt(_type,_name)       %nullref_fmt() %varfail_fmt(_type, _name)  		   
+#define %outnullref_fmt(_type)             %nullref_fmt() %outfail_fmt(_type)         
+
+/* setting an error */
+#define %error(code,msg...)               SWIG_Error(code, msg)
+#define %type_error(msg...)               SWIG_Error(SWIG_TypeError,  msg)
+
+
+
+%insert("runtime") {
+
+%define_as(SWIG_exception_fail(code, msg), %block(%error(code, msg); SWIG_fail))
+
+%define_as(SWIG_contract_assert(expr, msg), if (!(expr)) { %error(SWIG_RuntimeError, msg); SWIG_fail; } else)
+
+}
+
+#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_fail(SWIG_UnknownError, "Unknown exception");
+    }
+  }
+*/
+
+%fragment("<stdexcept>");
+
+%define SWIG_CATCH_STDEXCEPT
+  /* catching std::exception  */
+  catch (std::invalid_argument& e) {
+    SWIG_exception_fail(SWIG_ValueError, e.what() );
+  } catch (std::domain_error& e) {
+    SWIG_exception_fail(SWIG_ValueError, e.what() );
+  } catch (std::overflow_error& e) {
+    SWIG_exception_fail(SWIG_OverflowError, e.what() );
+  } catch (std::out_of_range& e) {
+    SWIG_exception_fail(SWIG_IndexError, e.what() );
+  } catch (std::length_error& e) {
+    SWIG_exception_fail(SWIG_IndexError, e.what() );
+  } catch (std::runtime_error& e) {
+    SWIG_exception_fail(SWIG_RuntimeError, e.what() );
+  } catch (std::exception& e) {
+    SWIG_exception_fail(SWIG_SystemError, e.what() );
+  }
+%enddef
+%define SWIG_CATCH_UNKNOWN
+  catch (std::exception& e) {
+    SWIG_exception_fail(SWIG_SystemError, e.what() );
+  }
+  catch (...) {
+    SWIG_exception_fail(SWIG_UnknownError, "unknown exception");
+  }
+%enddef
+
+
+#endif /* __cplusplus */
diff --git a/share/swig/2.0.11/typemaps/factory.swg b/share/swig/3.0.12/typemaps/factory.swg
index bccceb1..bccceb1 100644
--- a/share/swig/2.0.11/typemaps/factory.swg
+++ b/share/swig/3.0.12/typemaps/factory.swg
diff --git a/share/swig/3.0.12/typemaps/fragments.swg b/share/swig/3.0.12/typemaps/fragments.swg
new file mode 100644
index 0000000..3f33ca9
--- /dev/null
+++ b/share/swig/3.0.12/typemaps/fragments.swg
@@ -0,0 +1,298 @@
+/*
+  Fragments
+  =========
+  See the "Typemap fragments" section in the documentation for understanding
+  fragments. Below is some info on how fragments and automatic type
+  specialization is used.
+
+  Macros that make the automatic generation of typemaps easier are provided.
+
+  Consider the following code:
+
+      %fragment(SWIG_From_frag(bool), "header") {     
+      static PyObject*		      
+      SWIG_From_dec(bool)(bool value)	       
+      {					       
+        PyObject *obj = value ? Py_True : Py_False;  
+        Py_INCREF(obj);			       
+        return obj;				       
+      }					       
+      }					       
+      					 
+      %typemap(out, fragment=SWIG_From_frag(bool)) bool {
+        $result = SWIG_From(bool)($1));
+      }
+
+  Here the macros
+
+      SWIG_From_frag  => fragment 
+      SWIG_From_dec   => declaration 
+      SWIG_From       => call 
+      
+  allow you to define/include a fragment, and declare and call the
+  'from-bool' method as needed. In the simpler case, these macros 
+  just return something like
+
+      SWIG_From_frag(bool)  => "SWIG_From_bool"
+      SWIG_From_dec(bool)   =>  SWIG_From_bool
+      SWIG_From(bool)       =>  SWIG_From_bool
+
+  But they are specialized for the different languages requirements,
+  such as perl or tcl that requires passing the interpreter pointer,
+  and also they can manage C++ ugly types, for example:
+  
+      SWIG_From_frag(std::complex<double>)  => "SWIG_From_std_complex_Sl_double_Sg_"
+      SWIG_From_dec(std::complex<double>)   =>  SWIG_From_std_complex_Sl_double_Sg_
+      SWIG_From(std::complex<double>)       =>  SWIG_From_std_complex_Sl_double_Sg_
+
+
+  Hence, to declare methods to use with typemaps, always use the
+  SWIG_From* macros. In the same way, the SWIG_AsVal* and SWIG_AsPtr*
+  set of macros are provided.
+    
+*/
+
+
+/* -----------------------------------------------------------------------------
+ * Define the basic macros to 'normalize' the type fragments
+ * ----------------------------------------------------------------------------- */
+
+#ifndef SWIG_AS_DECL_ARGS
+#define SWIG_AS_DECL_ARGS
+#endif
+
+#ifndef SWIG_FROM_DECL_ARGS
+#define SWIG_FROM_DECL_ARGS
+#endif
+
+#ifndef SWIG_AS_CALL_ARGS
+#define SWIG_AS_CALL_ARGS
+#endif
+
+#ifndef SWIG_FROM_CALL_ARGS
+#define SWIG_FROM_CALL_ARGS
+#endif
+
+#define %fragment_name(Name, Type...)     %string_name(Name) "_" {Type}
+
+#define SWIG_Traits_frag(Type...) %fragment_name(Traits, Type) 
+#define SWIG_AsPtr_frag(Type...)  %fragment_name(AsPtr, Type)	 
+#define SWIG_AsVal_frag(Type...)  %fragment_name(AsVal, Type)	 
+#define SWIG_From_frag(Type...)   %fragment_name(From, Type)	 
+
+#define SWIG_AsVal_name(Type...)  %symbol_name(AsVal, Type) 
+#define SWIG_AsPtr_name(Type...)  %symbol_name(AsPtr, Type) 
+#define SWIG_From_name(Type...)   %symbol_name(From, Type)  
+
+#define SWIG_AsVal_dec(Type...)   SWIG_AsVal_name(Type) SWIG_AS_DECL_ARGS
+#define SWIG_AsPtr_dec(Type...)   SWIG_AsPtr_name(Type) SWIG_AS_DECL_ARGS
+#define SWIG_From_dec(Type...)    SWIG_From_name(Type)  SWIG_FROM_DECL_ARGS 
+
+#define SWIG_AsVal(Type...)       SWIG_AsVal_name(Type) SWIG_AS_CALL_ARGS 
+#define SWIG_AsPtr(Type...)  	  SWIG_AsPtr_name(Type) SWIG_AS_CALL_ARGS 	 
+#define SWIG_From(Type...)   	  SWIG_From_name(Type)  SWIG_FROM_CALL_ARGS 
+
+/* ------------------------------------------------------------
+ * common fragments 
+ * ------------------------------------------------------------ */
+
+/* Default compiler options for gcc allow long_long but not LLONG_MAX. 
+ * Define SWIG_NO_LLONG_MAX if this added limits support is not wanted. */
+%fragment("<limits.h>","header") %{
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
+%}
+
+%fragment("<math.h>","header") %{
+#include <math.h>
+%}
+
+%fragment("<wchar.h>","header") %{
+#include <wchar.h>
+#include <limits.h>
+#ifndef WCHAR_MIN
+#  define WCHAR_MIN 0
+#endif
+#ifndef WCHAR_MAX
+#  define WCHAR_MAX 65535
+#endif
+%}
+
+%fragment("<float.h>","header") %{
+#include <float.h>
+%}
+
+%fragment("<stdio.h>","header") %{
+#include <stdio.h>
+#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
+# ifndef snprintf
+#  define snprintf _snprintf
+# endif
+#endif
+%}
+
+%fragment("<stdlib.h>","header") %{
+#include <stdlib.h>
+#ifdef _MSC_VER
+# ifndef strtoull
+#  define strtoull _strtoui64
+# endif
+# ifndef strtoll
+#  define strtoll _strtoi64
+# endif
+#endif
+%}
+
+%fragment("<stddef.h>", "header") %{
+#include <stddef.h>
+%}
+
+%fragment("<string>", "header") %{
+#include <string>
+%}
+
+%fragment("<stdexcept>", "header") %{
+#include <stdexcept>
+%}
+
+%fragment("<algorithm>", "header") %{
+#include <algorithm>
+%}
+
+%fragment("SWIG_isfinite","header",fragment="<math.h>,<float.h>") %{
+/* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */
+#ifndef SWIG_isfinite
+/* isfinite() is a macro for C99 */
+# if defined(isfinite)
+#  define SWIG_isfinite(X) (isfinite(X))
+# elif defined __cplusplus && __cplusplus >= 201103L
+/* Use a template so that this works whether isfinite() is std::isfinite() or
+ * in the global namespace.  The reality seems to vary between compiler
+ * versions.
+ *
+ * Make sure namespace std exists to avoid compiler warnings.
+ *
+ * extern "C++" is required as this fragment can end up inside an extern "C" { } block
+ */
+namespace std { }
+extern "C++" template<typename T>
+inline int SWIG_isfinite_func(T x) {
+  using namespace std;
+  return isfinite(x);
+}
+#  define SWIG_isfinite(X) (SWIG_isfinite_func(X))
+# elif defined(_MSC_VER)
+#  define SWIG_isfinite(X) (_finite(X))
+# elif defined(__sun) && defined(__SVR4)
+#  include <ieeefp.h>
+#  define SWIG_isfinite(X) (finite(X))
+# endif
+#endif
+%}
+
+%fragment("SWIG_Float_Overflow_Check","header",fragment="<float.h>,SWIG_isfinite") %{
+/* Accept infinite as a valid float value unless we are unable to check if a value is finite */
+#ifdef SWIG_isfinite
+# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX) && SWIG_isfinite(X))
+#else
+# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX))
+#endif
+%}
+
+/* -----------------------------------------------------------------------------
+ * special macros for fragments
+ * ----------------------------------------------------------------------------- */
+
+/* Macros to derive numeric types */
+
+%define %numeric_type_from(Type, Base)
+%fragment(SWIG_From_frag(Type),"header",
+	  fragment=SWIG_From_frag(Base)) {
+SWIGINTERNINLINE SWIG_Object
+SWIG_From_dec(Type)(Type value)
+{    
+  return SWIG_From(Base)(value);
+}
+}
+%enddef
+
+%define %numeric_type_asval(Type, Base, Frag, OverflowCond)
+%fragment(SWIG_AsVal_frag(Type),"header",
+	  fragment=Frag,
+	  fragment=SWIG_AsVal_frag(Base)) {
+SWIGINTERN int
+SWIG_AsVal_dec(Type)(SWIG_Object obj, Type *val)
+{
+  Base v;
+  int res = SWIG_AsVal(Base)(obj, &v);
+  if (SWIG_IsOK(res)) {
+    if (OverflowCond) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = %numeric_cast(v, Type);
+    }
+  }  
+  return res;
+}
+}
+%enddef
+
+#define %numeric_signed_type_asval(Type, Base, Frag, Min, Max) \
+%numeric_type_asval(Type, Base, Frag, (v < Min || v > Max))
+
+#define %numeric_unsigned_type_asval(Type, Base, Frag, Max) \
+%numeric_type_asval(Type, Base, Frag, (v > Max))
+
+
+/* Macro for 'signed long' derived types */
+
+%define %numeric_slong(Type, Frag, Min, Max)
+%numeric_type_from(Type, long)
+%numeric_signed_type_asval(Type, long, Frag , Min, Max)
+%enddef
+
+/* Macro for 'unsigned long' derived types */
+
+%define %numeric_ulong(Type, Frag, Max)
+%numeric_type_from(Type, unsigned long)
+%numeric_unsigned_type_asval(Type, unsigned long, Frag, Max)
+%enddef
+
+
+/* Macro for floating point derived types (original macro) */
+
+%define %numeric_double(Type, Frag, Min, Max)
+%numeric_type_from(Type, double)
+%numeric_signed_type_asval(Type, double, Frag , Min, Max)
+%enddef
+
+/* Macro for floating point derived types */
+
+%define %numeric_float(Type, Frag, OverflowCond)
+%numeric_type_from(Type, double)
+%numeric_type_asval(Type, double, Frag, OverflowCond)
+%enddef
+
+
+/* Macros for missing fragments */
+
+%define %ensure_fragment(Fragment)
+%fragment(`Fragment`,"header") {
+%#error "SWIG language implementation must provide the Fragment fragment"
+}
+%enddef
+
+%define %ensure_type_fragments(Type)
+%fragment(SWIG_From_frag(Type),"header") {
+%#error "SWIG language implementation must provide a SWIG_From_frag(Type) fragment"
+}
+%fragment(SWIG_AsVal_frag(Type),"header") {
+%#error "SWIG language implementation must provide a SWIG_AsVal_frag(Type) fragment"
+}
+%enddef
diff --git a/share/swig/3.0.12/typemaps/implicit.swg b/share/swig/3.0.12/typemaps/implicit.swg
new file mode 100644
index 0000000..2fc3108
--- /dev/null
+++ b/share/swig/3.0.12/typemaps/implicit.swg
@@ -0,0 +1,208 @@
+/*
+  The %implicit macro allows a SwigType (Class) to be accepted
+  as an input parameter and use its implicit constructors when needed.
+
+  For example:
+
+
+  %implicit(A, int, double, B);
+
+  %inline 
+  {
+    struct B { };  
+    struct A
+    {
+      int ii;
+      A(int i) { ii = 1; }
+      A(double d) { ii = 2; }
+      A(const B& b) { ii = 3; }
+    };
+  
+    int get(A a) { return a.ii; }
+  }
+
+  Here, you can call 'get' as 
+
+    get(1)    ==> get(A(1))
+    get(2.0)  ==> get(A(2.0))
+    get(B())  ==> get(A(B()))
+
+   and swig will construct an 'A' temporal variable using the
+   corresponding implicit constructor.
+
+
+  The plain implicit macro takes care of simple type list. If it doesn't
+  work because you are passing template types with commas, then use
+  the %implicit_{1,2,3} versions and/or the %arg macro.
+
+*/
+
+%define %implicit_type(Type...)
+%traits_swigtype(Type);
+%enddef
+
+%define %implicit_frag(Type...) ,fragment=SWIG_Traits_frag(Type) %enddef
+
+%define %implicit_code(Type...)
+{
+  Type _v;
+  int res = swig::asval<Type >(obj, &_v);  
+  if (SWIG_IsOK(res)) {
+    if (val) *val = new value_type(static_cast<const Type& >(_v));
+    return SWIG_AddNewMask(res);
+  }
+}
+%enddef
+
+/* implicit */
+
+%define %implicit(Type, ...)
+
+%formacro_1(%implicit_type,__VA_ARGS__);
+
+%fragment(SWIG_Traits_frag(Type),"header",
+	  fragment="StdTraits"
+          %formacro_1(%implicit_frag,__VA_ARGS__)) %{
+namespace swig {
+  template <>  struct traits<Type > {   
+    typedef pointer_category category;
+    static const char* type_name() { return "Type"; }
+  };
+   
+  template <> struct traits_asptr< Type > {
+  typedef Type value_type;
+  static int asptr(SWIG_Object obj, value_type **val) { 
+    Type *vptr;
+    static swig_type_info* descriptor = SWIG_TypeQuery("Type *");
+    int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&vptr, descriptor, 0) : SWIG_ERROR;
+    if (SWIG_IsOK(res)) {
+      if (val) *val = vptr;
+      return res;
+    } else {
+      %formacro_1(%implicit_code,__VA_ARGS__)
+    }
+    return SWIG_TypeError;
+  }
+ };
+}
+%}
+
+%typemap_traits_ptr(%checkcode(POINTER),Type);
+%enddef
+
+/* implicit_1 */
+
+
+%define %implicit_1(Type, Imp1)
+%traits_swigtype(Imp1);
+
+%fragment(SWIG_Traits_frag(Type),"header",
+	  fragment="StdTraits",
+	  fragment=SWIG_Traits_frag(Imp1)) %{
+namespace swig {
+  template <>  struct traits< Type > {   
+    typedef pointer_category category;
+    static const char* type_name() { return "Type"; }
+  };
+   
+  template <> struct traits_asptr< Type > {   
+  typedef Type value_type;
+  static int asptr(SWIG_Object obj, value_type **val) { 
+    Type *vptr;
+    static swig_type_info* descriptor = SWIG_TypeQuery("Type *");
+    int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&vptr, descriptor, 0) : SWIG_ERROR;
+    if (SWIG_IsOK(res)) {
+      if (val) *val = vptr;
+      return res;
+    } else {
+      %implicit_code(Imp1);
+    }
+    return SWIG_TypeError;
+  }
+ };
+}
+%}
+
+%typemap_traits_ptr(%checkcode(POINTER),Type);
+
+%enddef
+
+/* implicit_2 */
+
+%define %implicit_2(Type, Imp1, Imp2)
+%traits_swigtype(Imp1);
+%traits_swigtype(Imp2);
+
+%fragment(SWIG_Traits_frag(Type),"header",
+	  fragment="StdTraits",
+	  fragment=SWIG_Traits_frag(Imp1),
+	  fragment=SWIG_Traits_frag(Imp2)) %{
+namespace swig {
+  template <>  struct traits< Type > {   
+    typedef pointer_category category;
+    static const char* type_name() { return "Type"; }
+  };
+
+  template <> struct traits_asptr< Type > {   
+  typedef Type value_type;
+  static int asptr(SWIG_Object obj, value_type **val) { 
+    Type *vptr;
+    static swig_type_info* descriptor = SWIG_TypeQuery("Type *");
+    int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&vptr, descriptor, 0) : SWIG_ERROR;
+    if (SWIG_IsOK(res)) {
+      if (val) *val = vptr;
+      return SWIG_OLDOBJ;
+    } else {
+      %implicit_code(Imp1);
+      %implicit_code(Imp2);
+    }
+    return SWIG_TypeError;
+  }
+ };
+}
+%}
+
+%typemap_traits_ptr(%checkcode(POINTER),Type);
+%enddef
+
+
+/* implicit_3 */
+
+%define %implicit_3(Type, Imp1, Imp2, Imp3)
+%traits_swigtype(Imp1);
+%traits_swigtype(Imp2);
+%traits_swigtype(Imp3);
+
+%fragment(SWIG_Traits_frag(Type),"header",
+	  fragment="StdTraits",
+	  fragment=SWIG_Traits_frag(Imp1),
+	  fragment=SWIG_Traits_frag(Imp2),
+	  fragment=SWIG_Traits_frag(Imp3)) %{
+namespace swig {
+  template <>  struct traits< Type > {   
+    typedef pointer_category category;
+    static const char* type_name() { return "Type"; }
+  };
+
+  template <> struct traits_asptr< Type > {   
+    typedef Type value_type;
+    static int asptr(SWIG_Object obj, value_type **val) { 
+    Type *vptr;
+    static swig_type_info* descriptor = SWIG_TypeQuery("Type *");
+    int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&vptr, descriptor, 0) : SWIG_ERROR;
+    if (SWIG_IsOK(res)) {
+      if (val) *val = vptr;
+      return res;
+    } else {
+      %implicit_code(Imp1);
+      %implicit_code(Imp2);
+      %implicit_code(Imp3);
+    }
+    return SWIG_TypeError;
+  }
+ };
+}
+%}
+
+%typemap_traits_ptr(%checkcode(POINTER),Type);
+%enddef
diff --git a/share/swig/2.0.11/typemaps/inoutlist.swg b/share/swig/3.0.12/typemaps/inoutlist.swg
index 23fda85..23fda85 100644
--- a/share/swig/2.0.11/typemaps/inoutlist.swg
+++ b/share/swig/3.0.12/typemaps/inoutlist.swg
diff --git a/share/swig/2.0.11/typemaps/misctypes.swg b/share/swig/3.0.12/typemaps/misctypes.swg
index 09c81d7..09c81d7 100644
--- a/share/swig/2.0.11/typemaps/misctypes.swg
+++ b/share/swig/3.0.12/typemaps/misctypes.swg
diff --git a/share/swig/3.0.12/typemaps/primtypes.swg b/share/swig/3.0.12/typemaps/primtypes.swg
new file mode 100644
index 0000000..dd80eb7
--- /dev/null
+++ b/share/swig/3.0.12/typemaps/primtypes.swg
@@ -0,0 +1,367 @@
+/* ------------------------------------------------------------
+ * Primitive type fragments and macros 
+ * ------------------------------------------------------------ */
+
+/*
+  This file provide fragments and macros for the C/C++ primitive types. 
+
+  The file defines default fragments for the following types:
+
+    bool
+    signed char
+    unsigned char
+    signed wchar_t     // in C++
+    unsigned wchar_t   // in C++
+    short
+    unsigned short
+    int
+    unsigned int
+    float
+    size_t
+    ptrdiff_t
+
+  which can always be redefined in the swig target language if needed.
+  
+  The fragments for the following types, however, always need to be
+  defined in the target language:
+
+    long
+    unsigned long
+    long long
+    unsigned long long
+    double
+ 
+  If they are not provided, an #error directive will appear in the
+  wrapped code.
+
+  --------------------------------------------------------------------
+  
+  This file provides the macro
+
+    %typemaps_primitive(CheckCode, Type)
+
+  which generates the typemaps for a primitive type with a given
+  checkcode. It is assumed that the primitive type is 'normalized' and
+  the corresponding SWIG_AsVal(Type) and SWIG_From(Type) methods are
+  provided via fragments.
+  
+   
+  The following auxiliary macros (explained with bash pseudo code) are
+  also defined:
+
+    %apply_ctypes(Macro)
+      for i in C Type
+      do
+        Macro($i)
+      done
+
+    %apply_cpptypes(Macro)
+      for i in C++ Type
+      do
+        Macro($i)
+      done
+
+    %apply_ctypes_2(Macro2)
+       for i in C Type
+       do
+         for j in C Type
+         do
+            Macro_2($i, $j)
+         done
+       done
+
+    %apply_cpptypes_2(Macro2)
+       for i in C++ Type
+       do
+         for j in C++ Type
+         do
+            Macro_2($i, $j)
+         done
+       done
+
+    %apply_checkctypes(Macro2)
+       for i in Check Type
+       do
+         Macro2(%checkcode($i), $i)
+       done
+
+*/
+
+
+/* ------------------------------------------------------------
+ * Primitive type fragments 
+ * ------------------------------------------------------------ */
+/* boolean */
+
+%fragment(SWIG_From_frag(bool),"header",fragment=SWIG_From_frag(long)) {
+SWIGINTERN SWIG_Object
+SWIG_From_dec(bool)(bool value)
+{    
+  return SWIG_From(long)(value ? 1 : 0);
+}
+}
+
+%fragment(SWIG_AsVal_frag(bool),"header",fragment=SWIG_AsVal_frag(long)) {
+SWIGINTERN int
+SWIG_AsVal_dec(bool)(SWIG_Object obj, bool *val)
+{
+  long v;
+  int res = SWIG_AsVal(long)(obj, val ? &v : 0);
+  if (SWIG_IsOK(res)) {    
+    if (val) *val = v ? true : false;
+    return res;
+  }  
+  return SWIG_TypeError;
+}
+}
+
+/* signed/unsigned char */
+
+%numeric_slong(signed char,     "<limits.h>", SCHAR_MIN, SCHAR_MAX)
+%numeric_ulong(unsigned char,   "<limits.h>", UCHAR_MAX)
+
+/* short/unsigned short */
+
+%numeric_slong(short,           "<limits.h>", SHRT_MIN, SHRT_MAX)
+%numeric_ulong(unsigned short,  "<limits.h>", USHRT_MAX)
+
+/* int/unsigned int */
+
+%numeric_slong(int,             "<limits.h>", INT_MIN, INT_MAX)
+%numeric_ulong(unsigned int,    "<limits.h>", UINT_MAX)
+
+/* signed/unsigned wchar_t */
+
+#ifdef __cplusplus
+%numeric_slong(signed wchar_t,   "<wchar.h>", WCHAR_MIN, WCHAR_MAX)
+%numeric_ulong(unsigned wchar_t, "<wchar.h>", UWCHAR_MAX)
+#endif
+
+/* float */
+
+%numeric_float(float,           "SWIG_Float_Overflow_Check", SWIG_Float_Overflow_Check(v))
+
+/* long/unsigned long */
+
+%ensure_type_fragments(long)
+%ensure_type_fragments(unsigned long)
+
+/* long long/unsigned long long */
+
+%fragment("SWIG_LongLongAvailable","header", fragment="<limits.h>") %{
+#if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
+#  define SWIG_LONG_LONG_AVAILABLE
+#endif
+%}
+
+%ensure_type_fragments(long long)
+%ensure_type_fragments(unsigned long long)
+
+/* double */
+
+%ensure_type_fragments(double)
+
+/* size_t */
+
+%fragment(SWIG_From_frag(size_t),"header",fragment=SWIG_From_frag(unsigned long),fragment=SWIG_From_frag(unsigned long long)) {
+SWIGINTERNINLINE SWIG_Object
+SWIG_From_dec(size_t)(size_t value)
+{    
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+  if (sizeof(size_t) <= sizeof(unsigned long)) {
+%#endif
+    return SWIG_From(unsigned long)(%numeric_cast(value, unsigned long));
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+  } else {
+    /* assume sizeof(size_t) <= sizeof(unsigned long long) */
+    return SWIG_From(unsigned long long)(%numeric_cast(value, unsigned long long));
+  }
+%#endif
+}
+}
+
+%fragment(SWIG_AsVal_frag(size_t),"header",fragment=SWIG_AsVal_frag(unsigned long),fragment=SWIG_AsVal_frag(unsigned long long)) {
+SWIGINTERNINLINE int
+SWIG_AsVal_dec(size_t)(SWIG_Object obj, size_t *val)
+{
+  int res = SWIG_TypeError;
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+  if (sizeof(size_t) <= sizeof(unsigned long)) {
+%#endif
+    unsigned long v;
+    res = SWIG_AsVal(unsigned long)(obj, val ? &v : 0);
+    if (SWIG_IsOK(res) && val) *val = %numeric_cast(v, size_t);
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+  } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
+    unsigned long long v;
+    res = SWIG_AsVal(unsigned long long)(obj, val ? &v : 0);
+    if (SWIG_IsOK(res) && val) *val = %numeric_cast(v, size_t);
+  }
+%#endif
+  return res;
+}
+}
+
+/* ptrdiff_t */
+
+%fragment(SWIG_From_frag(ptrdiff_t),"header",fragment=SWIG_From_frag(long),fragment=SWIG_From_frag(long long)) {
+SWIGINTERNINLINE SWIG_Object
+SWIG_From_dec(ptrdiff_t)(ptrdiff_t value)
+{    
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+  if (sizeof(ptrdiff_t) <= sizeof(long)) {
+%#endif
+    return SWIG_From(long)(%numeric_cast(value, long));
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+  } else {
+    /* assume sizeof(ptrdiff_t) <= sizeof(long long) */
+    return SWIG_From(long long)(%numeric_cast(value, long long));
+  }
+%#endif
+}
+}
+
+%fragment(SWIG_AsVal_frag(ptrdiff_t),"header",fragment=SWIG_AsVal_frag(long),fragment=SWIG_AsVal_frag(long long)) {
+SWIGINTERNINLINE int
+SWIG_AsVal_dec(ptrdiff_t)(SWIG_Object obj, ptrdiff_t *val)
+{
+  int res = SWIG_TypeError;
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+  if (sizeof(ptrdiff_t) <= sizeof(long)) {
+%#endif
+    long v;
+    res = SWIG_AsVal(long)(obj, val ? &v : 0);
+    if (SWIG_IsOK(res) && val) *val = %numeric_cast(v, ptrdiff_t);
+%#ifdef SWIG_LONG_LONG_AVAILABLE
+  } else if (sizeof(ptrdiff_t) <= sizeof(long long)) {
+    long long v;
+    res = SWIG_AsVal(long long)(obj, val ? &v : 0);
+    if (SWIG_IsOK(res) && val) *val = %numeric_cast(v, ptrdiff_t);
+  }
+%#endif
+  return res;
+}
+}
+
+
+%fragment("SWIG_CanCastAsInteger","header",
+	  fragment=SWIG_AsVal_frag(double),
+	  fragment="<float.h>",
+	  fragment="<math.h>") {
+SWIGINTERNINLINE int
+SWIG_CanCastAsInteger(double *d, double min, double max) {
+  double x = *d;
+  if ((min <= x && x <= max)) {
+   double fx = floor(x);
+   double cx = ceil(x);
+   double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
+   if ((errno == EDOM) || (errno == ERANGE)) {
+     errno = 0;
+   } else {
+     double summ, reps, diff;
+     if (rd < x) {
+       diff = x - rd;
+     } else if (rd > x) {
+       diff = rd - x;
+     } else {
+       return 1;
+     }
+     summ = rd + x;
+     reps = diff/summ;
+     if (reps < 8*DBL_EPSILON) {
+       *d = rd;
+       return 1;
+     }
+   }
+  }
+  return 0;
+}
+}
+
+/* ------------------------------------------------------------
+ * Generate the typemaps for primitive type 
+ * ------------------------------------------------------------ */
+
+#define %typemaps_primitive(Code, Type) %typemaps_asvalfromn(%arg(Code), Type)
+
+/* ------------------------------------------------------------
+ * Primitive Type Macros
+ * ------------------------------------------------------------ */
+
+/* useful macros to derive typemap declarations from primitive types */
+
+%define _apply_macro(macro, arg2, arg1...)
+#if #arg1 != ""
+macro(%arg(arg1),arg2);
+#else
+macro(arg2);
+#endif
+%enddef
+
+/* Apply macro to the C-types */
+%define %apply_ctypes(Macro, Arg2...)
+_apply_macro(Macro, bool               , Arg2);
+_apply_macro(Macro, signed char        , Arg2);
+_apply_macro(Macro, unsigned char      , Arg2);
+_apply_macro(Macro, short              , Arg2);
+_apply_macro(Macro, unsigned short     , Arg2);
+_apply_macro(Macro, int                , Arg2);
+_apply_macro(Macro, unsigned int       , Arg2);
+_apply_macro(Macro, long               , Arg2);
+_apply_macro(Macro, unsigned long      , Arg2);
+_apply_macro(Macro, long long          , Arg2);
+_apply_macro(Macro, unsigned long long , Arg2);
+_apply_macro(Macro, float              , Arg2);
+_apply_macro(Macro, double             , Arg2);
+_apply_macro(Macro, char               , Arg2);
+_apply_macro(Macro, wchar_t            , Arg2);
+_apply_macro(Macro, size_t             , Arg2);
+_apply_macro(Macro, ptrdiff_t          , Arg2);
+%enddef
+
+/* apply the Macro2(Type1, Type2) to all  C types  */
+#define %apply_ctypes_2(Macro2) %apply_ctypes(%apply_ctypes, Macro2)
+
+
+/* apply the Macro(Type) to all  C++ types  */
+%define %apply_cpptypes(Macro, Arg2...)
+%apply_ctypes(Macro, Arg2)
+_apply_macro(Macro, std::size_t, Arg2);
+_apply_macro(Macro, std::ptrdiff_t, Arg2);
+_apply_macro(Macro, std::string, Arg2);
+_apply_macro(Macro, std::wstring, Arg2);
+_apply_macro(Macro, std::complex<float>, Arg2);
+_apply_macro(Macro, std::complex<double>, Arg2);
+%enddef
+
+/* apply the Macro2(Type1, Type2) to all  C++ types  */
+#define %apply_cpptypes_2(Macro2) %apply_cpptypes(%apply_cpptypes, Macro2)
+
+/* apply the Macro2(CheckCode,Type) to all  Checked Types */
+%define %apply_checkctypes(Macro2)
+Macro2(%checkcode(BOOL),    bool);
+Macro2(%checkcode(INT8),    signed char);
+Macro2(%checkcode(UINT8),   unsigned char);
+Macro2(%checkcode(INT16),   short);
+Macro2(%checkcode(UINT16),  unsigned short);
+Macro2(%checkcode(INT32),   int);
+Macro2(%checkcode(UINT32),  unsigned int);
+Macro2(%checkcode(INT64),   long);
+Macro2(%checkcode(UINT64),  unsigned long);
+Macro2(%checkcode(INT128),  long long);
+Macro2(%checkcode(UINT128), unsigned long long);
+Macro2(%checkcode(FLOAT),   float);
+Macro2(%checkcode(DOUBLE),  double);
+Macro2(%checkcode(CHAR),    char);
+Macro2(%checkcode(UNICHAR), wchar_t);
+Macro2(%checkcode(SIZE),    size_t);
+Macro2(%checkcode(PTRDIFF), ptrdiff_t);
+%enddef
+
+
+/* ------------------------------------------------------------
+ * Generate the typemaps for all the primitive types with checkcode
+ * ------------------------------------------------------------ */
+
+%apply_checkctypes(%typemaps_primitive);
+
diff --git a/share/swig/2.0.11/typemaps/ptrtypes.swg b/share/swig/3.0.12/typemaps/ptrtypes.swg
index e8439e6..e8439e6 100644
--- a/share/swig/2.0.11/typemaps/ptrtypes.swg
+++ b/share/swig/3.0.12/typemaps/ptrtypes.swg
diff --git a/share/swig/3.0.12/typemaps/std_except.swg b/share/swig/3.0.12/typemaps/std_except.swg
new file mode 100644
index 0000000..75d0664
--- /dev/null
+++ b/share/swig/3.0.12/typemaps/std_except.swg
@@ -0,0 +1,37 @@
+%include <typemaps/exception.swg>
+
+/* 
+   Mark all of std exception classes as "exception classes" via
+   the "exceptionclass" feature.
+   
+   If needed, you can disable it by using %noexceptionclass.
+*/
+
+%define %std_exception_map(Exception, Code)
+  %exceptionclass  Exception; 
+#if !defined(SWIG_STD_EXCEPTIONS_AS_CLASSES)
+  %typemap(throws,noblock=1) Exception {
+    SWIG_exception_fail(Code, $1.what());
+  }
+  %ignore Exception;
+  struct Exception {
+  };
+#endif
+%enddef
+
+namespace std {
+  %std_exception_map(bad_cast,           SWIG_TypeError);
+  %std_exception_map(bad_exception,      SWIG_SystemError);
+  %std_exception_map(domain_error,       SWIG_ValueError);
+  %std_exception_map(exception,          SWIG_SystemError);
+  %std_exception_map(invalid_argument,   SWIG_ValueError);
+  %std_exception_map(length_error,       SWIG_IndexError);
+  %std_exception_map(logic_error,        SWIG_RuntimeError);
+  %std_exception_map(out_of_range,       SWIG_IndexError);
+  %std_exception_map(overflow_error,     SWIG_OverflowError);
+  %std_exception_map(range_error,        SWIG_OverflowError);
+  %std_exception_map(runtime_error,      SWIG_RuntimeError);
+  %std_exception_map(underflow_error,    SWIG_OverflowError);
+}
+
+%include <std/std_except.i>
diff --git a/share/swig/3.0.12/typemaps/std_string.swg b/share/swig/3.0.12/typemaps/std_string.swg
new file mode 100644
index 0000000..5b57bea
--- /dev/null
+++ b/share/swig/3.0.12/typemaps/std_string.swg
@@ -0,0 +1,25 @@
+//
+// String
+//
+
+
+#ifndef SWIG_STD_BASIC_STRING
+#define SWIG_STD_STRING
+
+%include <typemaps/std_strings.swg>
+
+%fragment("<string>");
+
+namespace std
+{
+  %naturalvar string;
+  class string;
+}
+
+%typemaps_std_string(std::string, char, SWIG_AsCharPtrAndSize, SWIG_FromCharPtrAndSize, %checkcode(STDSTRING));
+
+#else
+
+%include <std/std_string.i>
+
+#endif
diff --git a/share/swig/2.0.11/typemaps/std_strings.swg b/share/swig/3.0.12/typemaps/std_strings.swg
index e9c23ba..e9c23ba 100644
--- a/share/swig/2.0.11/typemaps/std_strings.swg
+++ b/share/swig/3.0.12/typemaps/std_strings.swg
diff --git a/share/swig/3.0.12/typemaps/std_wstring.swg b/share/swig/3.0.12/typemaps/std_wstring.swg
new file mode 100644
index 0000000..4a2830b
--- /dev/null
+++ b/share/swig/3.0.12/typemaps/std_wstring.swg
@@ -0,0 +1,26 @@
+%include <typemaps/wstring.swg>
+
+#ifndef SWIG_STD_BASIC_STRING
+#define SWIG_STD_WSTRING
+
+%include <typemaps/std_strings.swg>
+
+%{
+#include <cwchar>
+%}
+%fragment("<string>");
+
+namespace std
+{
+  %naturalvar wstring;
+  class wstring;
+}
+
+%typemaps_std_string(std::wstring, wchar_t, SWIG_AsWCharPtrAndSize, SWIG_FromWCharPtrAndSize, %checkcode(STDUNISTRING));
+
+
+#else
+
+%include <std/std_wstring.i>
+
+#endif
diff --git a/share/swig/3.0.12/typemaps/string.swg b/share/swig/3.0.12/typemaps/string.swg
new file mode 100644
index 0000000..4b70723
--- /dev/null
+++ b/share/swig/3.0.12/typemaps/string.swg
@@ -0,0 +1,35 @@
+%ensure_fragment(SWIG_AsCharPtrAndSize)
+%ensure_fragment(SWIG_FromCharPtrAndSize)
+
+%types(char *);
+
+%fragment("SWIG_pchar_descriptor","header") {
+SWIGINTERN swig_type_info*
+SWIG_pchar_descriptor(void)
+{
+  static int init = 0;
+  static swig_type_info* info = 0;
+  if (!init) {
+    info = SWIG_TypeQuery("_p_char");
+    init = 1;
+  }
+  return info;
+}
+}
+
+%fragment("SWIG_strnlen","header",fragment="SWIG_FromCharPtrAndSize") {
+SWIGINTERN size_t
+SWIG_strnlen(const char* s, size_t maxlen)
+{
+  const char *p;
+  for (p = s; maxlen-- && *p; p++)
+    ;
+  return p - s;
+}
+}
+
+%include <typemaps/strings.swg>
+%typemaps_string(%checkcode(STRING), %checkcode(CHAR),
+		 char, Char, SWIG_AsCharPtrAndSize, SWIG_FromCharPtrAndSize,
+		 strlen, SWIG_strnlen,
+		"<limits.h>", CHAR_MIN, CHAR_MAX)
diff --git a/share/swig/3.0.12/typemaps/strings.swg b/share/swig/3.0.12/typemaps/strings.swg
new file mode 100644
index 0000000..87e97dd
--- /dev/null
+++ b/share/swig/3.0.12/typemaps/strings.swg
@@ -0,0 +1,651 @@
+//
+// Use the macro SWIG_PRESERVE_CARRAY_SIZE if you prefer to preserve
+// the size of char arrays, ie
+//  ------------------------------------------
+//       C Side             =>   Language Side
+//  ------------------------------------------
+//   char name[5] = "hola"  =>   'hola\0'
+//
+// the default behaviour is 
+//
+//   char name[5] = "hola"  =>   'hola'
+//
+//
+//#define SWIG_PRESERVE_CARRAY_SIZE
+
+/* ------------------------------------------------------------
+ *  String typemaps for type Char (char or wchar_t)
+ * ------------------------------------------------------------ */
+
+%define %_typemap_string(StringCode, 
+			 Char,
+			 SWIG_AsCharPtrAndSize,
+			 SWIG_FromCharPtrAndSize,
+			 SWIG_CharPtrLen,
+			 SWIG_CharBufLen,
+			 SWIG_AsCharPtr,
+			 SWIG_FromCharPtr,
+			 SWIG_AsCharArray,
+                         SWIG_NewCopyCharArray,
+                         SWIG_DeleteCharArray)
+
+/* in */
+
+%typemap(in,noblock=1,fragment=#SWIG_AsCharPtr) 
+  Char * (int res, Char *buf = 0, int alloc = 0),
+  const Char * (int res, Char *buf = 0, int alloc = 0) {
+  res = SWIG_AsCharPtr($input, &buf, &alloc);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res,"$type",$symname, $argnum);
+  }
+  $1 = %reinterpret_cast(buf, $1_ltype);
+}
+%typemap(freearg,noblock=1,match="in") Char *, const Char * {
+  if (alloc$argnum == SWIG_NEWOBJ) SWIG_DeleteCharArray(buf$argnum);
+}
+
+%typemap(in,noblock=1,fragment=#SWIG_AsCharPtr) Char const*& (int res, Char *buf = 0, int alloc = 0) {
+  res = SWIG_AsCharPtr($input, &buf, &alloc);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res,"$type",$symname, $argnum);
+  }
+  $1 = &buf;
+}    
+%typemap(freearg, noblock=1,match="in") Char const*& {
+  if (alloc$argnum == SWIG_NEWOBJ) SWIG_DeleteCharArray(buf$argnum);
+}
+
+/* out */
+
+%typemap(out,noblock=1,fragment=#SWIG_FromCharPtr) Char *, const Char * {
+  %set_output(SWIG_FromCharPtr((const Char *)$1));
+}
+
+
+%typemap(out,noblock=1,fragment=#SWIG_FromCharPtr) Char const*& {
+  %set_output(SWIG_FromCharPtr(*$1));
+}
+
+%typemap(newfree,noblock=1) Char * {
+  SWIG_DeleteCharArray($1);
+}
+
+/* varin */
+
+%typemap(varin,fragment=#SWIG_AsCharPtrAndSize) Char * {
+  Char *cptr = 0; size_t csize = 0; int alloc = SWIG_NEWOBJ;
+  int res = SWIG_AsCharPtrAndSize($input, &cptr, &csize, &alloc);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res,"$type","$name");
+  }
+  if ($1) SWIG_DeleteCharArray($1);
+  if (alloc == SWIG_NEWOBJ) {
+    $1 = cptr;
+  } else {
+    $1 = csize ? ($1_type)SWIG_NewCopyCharArray(cptr, csize, Char) : 0;
+  }
+}
+
+%typemap(varin,fragment=#SWIG_AsCharPtrAndSize,warning=SWIGWARN_TYPEMAP_CHARLEAK_MSG) const Char * {
+  Char *cptr = 0; size_t csize = 0; int alloc = SWIG_NEWOBJ;
+  int res = SWIG_AsCharPtrAndSize($input, &cptr, &csize, &alloc);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  if (alloc == SWIG_NEWOBJ) {
+    $1 = cptr;
+  } else {
+    $1 = csize ? ($1_type)SWIG_NewCopyCharArray(cptr, csize, Char) : 0;
+  }
+}
+
+/* varout */
+
+%typemap(varout,noblock=1,fragment=#SWIG_FromCharPtr) Char *, const Char * {
+  %set_varoutput(SWIG_FromCharPtr($1));
+}
+
+/* memberin */
+
+%typemap(memberin,noblock=1) Char * {
+  if ($1) SWIG_DeleteCharArray($1);
+  if ($input) {
+    size_t size = SWIG_CharPtrLen(%reinterpret_cast($input, const Char *)) + 1;
+    $1 = ($1_type)SWIG_NewCopyCharArray(%reinterpret_cast($input, const Char *), size, Char);
+  } else {
+    $1 = 0;
+  }
+}
+
+%typemap(memberin,noblock=1,warning=SWIGWARN_TYPEMAP_CHARLEAK_MSG) const Char * {
+  if ($input) {
+    size_t size = SWIG_CharPtrLen(%reinterpret_cast(%reinterpret_cast($input, const Char *), const Char *)) + 1;
+    $1 = ($1_type)SWIG_NewCopyCharArray($input, size, Char);
+  } else {
+    $1 = 0;
+  }
+}
+
+/* globalin */
+
+%typemap(globalin,noblock=1) Char * {
+  if ($1) SWIG_DeleteCharArray($1);
+  if ($input) {
+    size_t size = SWIG_CharPtrLen(%reinterpret_cast(%reinterpret_cast($input, const Char *), const Char *)) + 1;
+    $1 = ($1_type)SWIG_NewCopyCharArray($input, size, Char);
+  } else {
+    $1 = 0;
+  }
+}
+
+%typemap(globalin,noblock=1,warning=SWIGWARN_TYPEMAP_CHARLEAK_MSG) const Char * {
+  if ($input) {
+    size_t size = SWIG_CharPtrLen($input) + 1;
+    $1 = ($1_type)SWIG_NewCopyCharArray($input, size, Char);
+  } else {
+    $1 = 0;
+  }
+}
+
+/* constant */
+
+%typemap(constcode,noblock=1,fragment=#SWIG_FromCharPtr)
+  Char *, Char const*, Char * const, Char const* const {
+  %set_constant("$symname", SWIG_FromCharPtr($value));
+}
+
+
+#if defined(SWIG_DIRECTOR_TYPEMAPS)
+
+/* directorin */
+
+%typemap(directorin,noblock=1,fragment=#SWIG_FromCharPtr)
+  Char *, Char const*, Char *const, Char const *const, 
+  Char const *&, Char *const &, Char const *const & {
+  $input = SWIG_FromCharPtr((const Char *)$1);
+}
+
+
+/* directorout */
+
+%typemap(directorout,noblock=1,fragment=#SWIG_AsCharPtr,warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) Char * (int res, Char *buf = 0, int alloc = SWIG_NEWOBJ) {
+  res = SWIG_AsCharPtr($input, &buf, &alloc);
+  if (!SWIG_IsOK(res)) {
+    %dirout_fail(res, "$type");
+  }
+  if (alloc == SWIG_NEWOBJ) {
+    swig_acquire_ownership_array(buf);
+  }
+  $result = %reinterpret_cast(buf, $1_ltype);
+}
+%typemap(directorfree,noblock=1) Char *
+{
+  if (director) {
+    director->swig_release_ownership(%as_voidptr($input));
+  }
+}
+
+
+%typemap(directorout,noblock=1,fragment=#SWIG_AsCharPtr,warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) Char *const& (int res, Char *buf = 0, int alloc = SWIG_NEWOBJ), Char const*const& (int res, Char *buf = 0, int alloc = SWIG_NEWOBJ) { 
+  res = SWIG_AsCharPtr($input, &buf, &alloc);
+  if (!SWIG_IsOK(res)) {
+    %dirout_fail(res, "$type");
+  }
+  static $*1_ltype tmp = buf;
+  $result = &tmp;
+  if (alloc == SWIG_NEWOBJ) {
+    swig_acquire_ownership_array(buf);
+  }
+}
+%typemap(directorfree,noblock=1)
+  Char * const&, Char const* const& {
+  if (director) {
+    director->swig_release_ownership(%as_voidptr(*$input));
+  }
+}
+
+#endif /* SWIG_DIRECTOR_TYPEMAPS */
+
+/* typecheck */
+
+%typemap(typecheck,noblock=1,precedence=StringCode,
+	 fragment=#SWIG_AsCharPtr) Char *, const Char *, Char const*& {
+  int res = SWIG_AsCharPtr($input, 0, 0);
+  $1 = SWIG_CheckState(res);
+}
+
+
+/* throws */
+
+%typemap(throws,noblock=1,fragment=#SWIG_FromCharPtr) Char * {
+  %raise(SWIG_FromCharPtr($1), "$type", 0);
+}
+
+
+/* ------------------------------------------------------------
+ *  Unknown size const Character array Char[ANY] handling
+ * ------------------------------------------------------------ */
+
+%apply Char * { Char [] };
+%apply const Char * { const Char [] };
+
+%typemap(varin,noblock=1,warning="462:Unable to set variable of type Char []") Char []
+{
+  %variable_fail(SWIG_AttributeError, "$type", "read-only $name");
+}
+
+
+/* ------------------------------------------------------------
+ *  Fixed size Character array Char[ANY] handling
+ * ------------------------------------------------------------ */
+
+/*  memberin and globalin typemaps  */
+
+%typemap(memberin,noblock=1) Char [ANY]
+{
+  if ($input) memcpy($1,$input,$1_dim0*sizeof(Char));
+  else memset($1,0,$1_dim0*sizeof(Char));
+}
+
+%typemap(globalin,noblock=1) Char [ANY]
+{
+  if ($input) memcpy($1,$input,$1_dim0*sizeof(Char));
+  else memset($1,0,$1_dim0*sizeof(Char));
+}
+
+/* in */
+
+%typemap(in,noblock=1,fragment=#SWIG_AsCharArray)
+  Char [ANY] (Char temp[$1_dim0], int res), 
+  const Char [ANY](Char temp[$1_dim0], int res)
+{  
+  res = SWIG_AsCharArray($input, temp, $1_dim0);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res,"$type",$symname, $argnum);
+  }
+  $1 = %reinterpret_cast(temp, $1_ltype);
+}
+%typemap(freearg) Char [ANY], const Char [ANY] "";
+
+%typemap(in,noblock=1,fragment=#SWIG_AsCharArray) const Char (&)[ANY] (Char temp[$1_dim0], int res)
+{  
+  res = SWIG_AsCharArray($input, temp, $1_dim0);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res,"$type",$symname, $argnum);
+  }
+  $1 = &temp;
+}
+%typemap(freearg) const Char (&)[ANY] "";
+
+%typemap(out,fragment=#SWIG_FromCharPtrAndSize,fragment=#SWIG_CharBufLen)
+  Char [ANY], const Char[ANY] 
+{
+%#ifndef SWIG_PRESERVE_CARRAY_SIZE
+  size_t size = SWIG_CharBufLen($1, $1_dim0);
+%#else
+  size_t size = $1_dim0;
+%#endif
+   %set_output(SWIG_FromCharPtrAndSize($1, size));
+}
+
+/* varin */
+
+%typemap(varin,fragment=#SWIG_AsCharArray) Char [ANY]
+{
+  int res = SWIG_AsCharArray($input, $1, $1_dim0);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+}
+
+/* varout */
+
+%typemap(varout,fragment=#SWIG_CharBufLen)
+  Char [ANY], const Char [ANY] {
+%#ifndef SWIG_PRESERVE_CARRAY_SIZE
+  size_t size = SWIG_CharBufLen($1, $1_dim0);
+%#else
+  size_t size = $1_dim0;
+%#endif
+  %set_varoutput(SWIG_FromCharPtrAndSize($1, size));
+}
+
+/* constant */
+
+%typemap(constcode,fragment=#SWIG_CharBufLen)
+  Char [ANY], const Char [ANY]
+{
+%#ifndef SWIG_PRESERVE_CARRAY_SIZE
+  size_t size = SWIG_CharBufLen($1, $1_dim0);
+%#else
+  size_t size = $value_dim0;
+%#endif
+  %set_constant("$symname", SWIG_FromCharPtrAndSize($value,size));
+}
+
+
+#if defined(SWIG_DIRECTOR_TYPEMAPS)
+
+/* directorin */
+%typemap(directorin,fragment=#SWIG_CharBufLen)
+  Char [ANY], const Char [ANY] 
+{
+%#ifndef SWIG_PRESERVE_CARRAY_SIZE
+  size_t size = SWIG_CharBufLen($1, $1_dim0);
+%#else
+  size_t size = $1_dim0;
+%#endif
+  $input = SWIG_FromCharPtrAndSize($1, size);
+}
+
+/* directorout */
+
+%typemap(directorout,noblock=1,fragment=#SWIG_AsCharArray)
+  Char [ANY] (Char temp[$result_dim0]),
+  const Char [ANY] (Char temp[$result_dim0], int res)
+{ 
+  res = SWIG_AsCharArray($input, temp, $result_dim0);
+  if (!SWIG_IsOK(res)) {
+    %dirout_fail(res, "$type");
+  }
+  $result = temp;
+}
+
+#endif /* SWIG_DIRECTOR_TYPEMAPS */
+
+/* typecheck */
+
+%typemap(typecheck,noblock=1,precedence=StringCode,
+	 fragment=#SWIG_AsCharArray)  
+  Char [ANY], const Char[ANY] {
+  int res = SWIG_AsCharArray($input, (Char *)0, $1_dim0);
+  $1 = SWIG_CheckState(res);
+}
+
+
+/* throws */
+
+%typemap(throws,fragment=#SWIG_CharBufLen)
+  Char [ANY], const Char[ANY]
+{
+%#ifndef SWIG_PRESERVE_CARRAY_SIZE
+  size_t size = SWIG_CharBufLen($1, $1_dim0);
+%#else
+  size_t size = $1_dim0;
+%#endif
+  %raise(SWIG_FromCharPtrAndSize($1, size), "$type", 0); 
+}
+
+/* -------------------------------------------------------------------
+ * --- Really fix size Char arrays, including '\0'chars at the end ---
+ * ------------------------------------------------------------------- */
+
+%typemap(varout,noblock=1,fragment=#SWIG_FromCharPtrAndSize)
+  Char FIXSIZE[ANY], const Char FIXSIZE[ANY]
+{
+  %set_varoutput(SWIG_FromCharPtrAndSize($1, $1_dim0));
+}
+
+%typemap(out,noblock=1,fragment=#SWIG_FromCharPtrAndSize)
+  Char FIXSIZE[ANY], const Char FIXSIZE[ANY]
+{
+  %set_output(SWIG_FromCharPtrAndSize($1, $1_dim0));
+}
+
+#if defined(SWIG_DIRECTOR_TYPEMAPS)
+
+%typemap(directorin,noblock=1,fragment=#SWIG_FromCharPtrAndSize)
+  Char FIXSIZE[ANY], const Char FIXSIZE[ANY]
+{
+  $input = SWIG_FromCharPtrAndSize($1, $1_dim0);
+}
+
+#endif /* SWIG_DIRECTOR_TYPEMAPS */
+
+%typemap(throws,noblock=1,fragment=#SWIG_FromCharPtrAndSize)
+  Char FIXSIZE[ANY], const Char FIXSIZE[ANY] {
+  %raise(SWIG_FromCharPtrAndSize($1, $1_dim0), "$type", 0); 
+}
+
+/* ------------------------------------------------------------
+ * --- String & length ---
+ * ------------------------------------------------------------ */
+
+/* Here len doesn't include the '0' terminator */
+%typemap(in,noblock=1,fragment=#SWIG_AsCharPtrAndSize) 
+  (Char *STRING, size_t LENGTH) (int res, Char *buf = 0, size_t size = 0, int alloc = 0),
+  (const Char *STRING, size_t LENGTH) (int res, Char *buf = 0, size_t size = 0, int alloc = 0)
+{
+  res = SWIG_AsCharPtrAndSize($input, &buf, &size, &alloc);
+  if (!SWIG_IsOK(res)) { 
+    %argument_fail(res,"$type",$symname, $argnum);
+  }  
+  $1 = %reinterpret_cast(buf, $1_ltype);
+  $2 = %numeric_cast(size - 1, $2_ltype);
+}
+%typemap(freearg,noblock=1,match="in") (Char *STRING, size_t LENGTH) {
+  if (alloc$argnum == SWIG_NEWOBJ) SWIG_DeleteCharArray(buf$argnum);
+}
+/* old 'int' form */
+%typemap(in) (Char *STRING, int LENGTH) = (Char *STRING, size_t LENGTH);
+%typemap(freearg) (Char *STRING, int LENGTH) = (Char *STRING, size_t LENGTH);
+
+
+/* Here size includes the '0' terminator */
+%typemap(in,noblock=1,fragment=#SWIG_AsCharPtrAndSize)
+  (Char *STRING, size_t SIZE) (int res, Char *buf = 0, size_t size = 0, int alloc = 0),
+  (const Char *STRING, size_t SIZE) (int res, Char *buf = 0, size_t size = 0, int alloc = 0)
+{
+  res = SWIG_AsCharPtrAndSize($input, &buf, &size, &alloc);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res,"$type",$symname, $argnum);
+  }
+  $1 = %reinterpret_cast(buf, $1_ltype);
+  $2 = %numeric_cast(size, $2_ltype);
+}
+%typemap(freearg,noblock=1,match="in") (Char *STRING, size_t SIZE) {
+  if (alloc$argnum == SWIG_NEWOBJ) SWIG_DeleteCharArray(buf$argnum);
+}
+/* old 'int' form */
+%typemap(in) (Char *STRING, int SIZE) = (Char *STRING, size_t SIZE);
+%typemap(freearg) (Char *STRING, int SIZE) = (Char *STRING, size_t SIZE);
+
+
+/* reverse order versions */
+
+/* Here len doesn't include the '0' terminator */
+%typemap(in,noblock=1,fragment=#SWIG_AsCharPtrAndSize) 
+  (size_t LENGTH, Char *STRING) (int res, Char *buf = 0, size_t size = 0, int alloc = 0),
+  (size_t LENGTH, const Char *STRING) (int res, Char *buf = 0, size_t size = 0, int alloc = 0)
+{
+  res = SWIG_AsCharPtrAndSize($input, &buf, &size, &alloc);
+  if (!SWIG_IsOK(res)) { 
+    %argument_fail(res,"$type",$symname, $argnum);
+  }  
+  $2 = %reinterpret_cast(buf, $2_ltype) ;
+  $1 = %numeric_cast(size - 1, $1_ltype) ;
+}
+%typemap(freearg, noblock=1, match="in") (size_t LENGTH, Char *STRING) {
+  if (alloc$argnum == SWIG_NEWOBJ) SWIG_DeleteCharArray(buf$argnum);
+}
+/* old 'int' form */
+%typemap(in) (int LENGTH, Char *STRING) = (size_t LENGTH, Char *STRING);
+%typemap(freearg) (int LENGTH, Char *STRING) = (size_t LENGTH, Char *STRING);
+
+/* Here size includes the '0' terminator */
+%typemap(in,noblock=1,fragment=#SWIG_AsCharPtrAndSize)
+  (size_t SIZE, Char *STRING) (int res, Char *buf = 0, size_t size = 0, int alloc = 0),
+  (size_t SIZE, const Char *STRING) (int res, Char *buf = 0, size_t size = 0, int alloc = 0)
+{
+  res = SWIG_AsCharPtrAndSize($input, &buf, &size, &alloc);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type",$symname, $argnum);
+  }
+  $2 = %reinterpret_cast(buf, $2_ltype) ;
+  $1 = %numeric_cast(size, $1_ltype) ;
+}
+%typemap(freearg, noblock=1, match="in") (size_t SIZE, Char *STRING) {
+  if (alloc$argnum == SWIG_NEWOBJ) SWIG_DeleteCharArray(buf$argnum);
+}
+/* old 'int' form */
+%typemap(in) (int SIZE, Char *STRING) = (size_t SIZE, Char *STRING);
+%typemap(freearg) (int SIZE, Char *STRING) = (size_t SIZE, Char *STRING);
+
+
+%enddef
+
+
+/* ------------------------------------------------------------
+ * --- String fragment methods ---
+ * ------------------------------------------------------------ */
+
+#ifndef %_typemap2_string
+%define %_typemap2_string(StringCode, CharCode,
+			 Char, CharName,
+			 SWIG_AsCharPtrAndSize,
+			 SWIG_FromCharPtrAndSize,
+			 SWIG_CharPtrLen,
+			 SWIG_CharBufLen,
+			 SWIG_NewCopyCharArray,
+			 SWIG_DeleteCharArray,
+			 FragLimits, CHAR_MIN, CHAR_MAX)
+  
+%fragment("SWIG_From"#CharName"Ptr","header",fragment=#SWIG_FromCharPtrAndSize) {
+SWIGINTERNINLINE SWIG_Object 
+SWIG_From##CharName##Ptr(const Char *cptr)
+{ 
+  return SWIG_FromCharPtrAndSize(cptr, (cptr ? SWIG_CharPtrLen(cptr) : 0));
+}
+}
+
+%fragment("SWIG_From"#CharName"Array","header",fragment=#SWIG_FromCharPtrAndSize) {
+SWIGINTERNINLINE SWIG_Object 
+SWIG_From##CharName##Array(const Char *cptr, size_t size)
+{ 
+  return SWIG_FromCharPtrAndSize(cptr, size);
+}
+}
+
+%fragment("SWIG_As" #CharName "Ptr","header",fragment=#SWIG_AsCharPtrAndSize) {
+%define_as(SWIG_As##CharName##Ptr(obj, val, alloc), SWIG_AsCharPtrAndSize(obj, val, NULL, alloc))
+}
+
+%fragment("SWIG_As" #CharName "Array","header",fragment=#SWIG_AsCharPtrAndSize) {
+SWIGINTERN int
+SWIG_As##CharName##Array(SWIG_Object obj, Char *val, size_t size)
+{ 
+  Char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
+  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
+  if (SWIG_IsOK(res)) {
+    /* special case of single char conversion when we don't need space for NUL */
+    if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
+    if (csize <= size) {
+      if (val) {
+	if (csize) memcpy(val, cptr, csize*sizeof(Char));
+	if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(Char));
+      }
+      if (alloc == SWIG_NEWOBJ) {
+	SWIG_DeleteCharArray(cptr);
+	res = SWIG_DelNewMask(res);
+      }      
+      return res;
+    }
+    if (alloc == SWIG_NEWOBJ) SWIG_DeleteCharArray(cptr);
+  }
+  return SWIG_TypeError;
+}
+}
+
+/* Char */
+
+%fragment(SWIG_From_frag(Char),"header",fragment=#SWIG_FromCharPtrAndSize) {
+SWIGINTERNINLINE SWIG_Object
+SWIG_From_dec(Char)(Char c) 
+{ 
+  return SWIG_FromCharPtrAndSize(&c,1);
+}
+}
+
+%fragment(SWIG_AsVal_frag(Char),"header",
+	  fragment="SWIG_As"#CharName"Array",
+	  fragment=FragLimits,
+	  fragment=SWIG_AsVal_frag(long)) {
+SWIGINTERN int
+SWIG_AsVal_dec(Char)(SWIG_Object obj, Char *val)
+{    
+  int res = SWIG_As##CharName##Array(obj, val, 1);
+  if (!SWIG_IsOK(res)) {
+    long v;
+    res = SWIG_AddCast(SWIG_AsVal(long)(obj, &v));
+    if (SWIG_IsOK(res)) {
+      if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
+	if (val) *val = %numeric_cast(v, Char);
+      } else {
+	res = SWIG_OverflowError;
+      }
+    }
+  }
+  return res;
+}
+}
+
+%_typemap_string(StringCode, 
+		 Char,
+		 SWIG_AsCharPtrAndSize,
+		 SWIG_FromCharPtrAndSize,
+		 SWIG_CharPtrLen,
+		 SWIG_CharBufLen,
+		 SWIG_As##CharName##Ptr,
+		 SWIG_From##CharName##Ptr,
+		 SWIG_As##CharName##Array,
+		 SWIG_NewCopyCharArray,
+		 SWIG_DeleteCharArray)
+
+%enddef
+#endif
+
+/* ------------------------------------------------------------
+ *  String typemaps and fragments, with default allocators
+ * ------------------------------------------------------------ */
+
+%define %typemaps_string(StringCode, CharCode,
+			 Char, CharName,
+			 SWIG_AsCharPtrAndSize,
+			 SWIG_FromCharPtrAndSize,
+			 SWIG_CharPtrLen,
+			 SWIG_CharBufLen,
+			 FragLimits, CHAR_MIN, CHAR_MAX)
+%_typemap2_string(StringCode, CharCode,
+		  Char, CharName,
+		  SWIG_AsCharPtrAndSize,
+		  SWIG_FromCharPtrAndSize,
+		  SWIG_CharPtrLen,
+		  SWIG_CharBufLen,
+		  %new_copy_array,
+		  %delete_array,
+		  FragLimits, CHAR_MIN, CHAR_MAX)
+%enddef
+
+/* ------------------------------------------------------------
+ *  String typemaps and fragments, with custom allocators
+ * ------------------------------------------------------------ */
+
+%define %typemaps_string_alloc(StringCode, CharCode,
+			       Char, CharName,
+			       SWIG_AsCharPtrAndSize,
+			       SWIG_FromCharPtrAndSize,
+			       SWIG_CharPtrLen,
+			       SWIG_CharBufLen,
+			       SWIG_NewCopyCharArray,
+			       SWIG_DeleteCharArray,
+			       FragLimits, CHAR_MIN, CHAR_MAX)
+%_typemap2_string(StringCode, CharCode,
+		  Char, CharName,
+		  SWIG_AsCharPtrAndSize,
+		  SWIG_FromCharPtrAndSize,
+		  SWIG_CharPtrLen,
+		  SWIG_CharBufLen,
+		  SWIG_NewCopyCharArray,
+		  SWIG_DeleteCharArray,
+		  FragLimits, CHAR_MIN, CHAR_MAX)
+%enddef
diff --git a/share/swig/3.0.12/typemaps/swigmacros.swg b/share/swig/3.0.12/typemaps/swigmacros.swg
new file mode 100644
index 0000000..3a63a25
--- /dev/null
+++ b/share/swig/3.0.12/typemaps/swigmacros.swg
@@ -0,0 +1,245 @@
+/* -----------------------------------------------------------------------------
+ * SWIG API. Portion only visible from SWIG
+ * ----------------------------------------------------------------------------- */
+/*
+  This file implements the internal macros of the 'SWIG API', which
+  are useful to implement all the SWIG target languages.
+
+  Basic preprocessor macros:
+  --------------------------
+
+    %arg(Arg)               Safe argument wrap
+    %str(Arg)               Stringify the argument
+    %begin_block            Begin an execution block
+    %end_block              End an execution block
+    %block(Block)           Execute Block as an execution block
+    %define_as(Def, Val)    Define 'Def' as 'Val', expanding Def and Val first
+    %ifcplusplus(V1, V2)    if C++ Mode; then V1; else V2; fi
+
+
+  Casting Operations:
+  -------------------
+
+  SWIG provides the following casting macros, which implement the
+  corresponding C++ casting operations:
+
+    %const_cast(a, Type)         const_cast<Type >(a)
+    %static_cast(a, Type)      	 static_cast<Type >(a)
+    %reinterpret_cast(a, Type) 	 reinterpret_cast<Type >(a)
+    %numeric_cast(a, Type)     	 static_cast<Type >(a)
+    %as_voidptr(a)            	 const_cast<void *>(static_cast<const void *>(a))
+    %as_voidptrptr(a)        	 reinterpret_cast<void **>(a)
+
+  or their C unsafe versions. In C++ we use the safe version unless
+  SWIG_NO_CPLUSPLUS_CAST is defined (usually via the -nocppcast swig flag).
+
+
+  Memory allocation:
+  ------------------
+
+  These allocation/freeing macros are safe to use in C or C++ and
+  dispatch the proper new/delete/delete[] or free/malloc calls as
+  needed.
+
+    %new_instance(Type)             Allocate a new instance of given Type
+    %new_copy(value,Type)           Allocate and initialize a new instance with 'value'
+    %new_array(size,Type)           Allocate a new array with given size and Type and zero initialize
+    %new_copy_array(cptr,size,Type) Allocate and initialize a new array from 'cptr'
+    %delete(cptr)                   Delete an instance
+    %delete_array(cptr)             Delete an array
+
+
+  Auxiliary loop macros:
+  ----------------------
+
+    %formacro(Macro, Args...) or %formacro_1(Macro, Args...)
+       for i in Args
+       do
+          Macro($i)
+       done
+
+    %formacro_2(Macro2, Args...)
+       for i,j in Args
+       do
+          Macro2($i, $j)
+       done
+
+
+  Flags and conditional macros:
+  -----------------------------
+
+     %mark_flag(flag)
+       flag := True
+
+     %evalif(flag,expr)
+       if flag; then
+         expr
+       fi
+
+     %evalif_2(flag1 flag2,expr)
+       if flag1 and flag2; then
+         expr
+       fi
+
+
+*/
+/* -----------------------------------------------------------------------------
+ * Basic preprocessor macros
+ * ----------------------------------------------------------------------------- */
+
+#define %arg(Arg...)        Arg
+#define %str(Arg)           `Arg`
+#ifndef %begin_block
+#  define %begin_block      do {
+#endif
+#ifndef %end_block
+#  define %end_block        } while(0)
+#endif
+#define %block(Block...)    %begin_block Block; %end_block
+
+/* define a new macro */
+%define %define_as(Def, Val...)%#define Def Val %enddef
+
+/* include C++ or else value */
+%define %ifcplusplus(cppval, nocppval)
+#ifdef __cplusplus
+cppval
+#else
+nocppval
+#endif
+%enddef
+
+/* insert the SWIGVERSION in the interface and the wrapper code */
+#if SWIG_VERSION
+%insert("header") {
+%define_as(SWIGVERSION,  SWIG_VERSION)
+%#define SWIG_VERSION SWIGVERSION
+}
+#endif
+
+
+
+/* -----------------------------------------------------------------------------
+ * Casting operators
+ * ----------------------------------------------------------------------------- */
+
+#if defined(SWIG_NO_CPLUSPLUS_CAST)
+/* Disable 'modern' cplusplus casting operators */
+# if defined(SWIG_CPLUSPLUS_CAST)
+#   undef SWIG_CPLUSPLUS_CAST
+# endif
+#endif
+
+#if defined(__cplusplus) && defined(SWIG_CPLUSPLUS_CAST)
+# define %const_cast(a,Type...)       const_cast< Type >(a)
+# define %static_cast(a,Type...)      static_cast< Type >(a)
+# define %reinterpret_cast(a,Type...) reinterpret_cast< Type >(a)
+# define %numeric_cast(a,Type...)     static_cast< Type >(a)
+#else /* C case */
+# define %const_cast(a,Type...)       (Type)(a)
+# define %static_cast(a,Type...)      (Type)(a)
+# define %reinterpret_cast(a,Type...) (Type)(a)
+# define %numeric_cast(a,Type...)     (Type)(a)
+#endif /* __cplusplus */
+
+
+#define %as_voidptr(a)               SWIG_as_voidptr(a)
+#define %as_voidptrptr(a)            SWIG_as_voidptrptr(a)
+
+%insert("header") {
+%define_as(SWIG_as_voidptr(a),    %const_cast(%static_cast(a,const void *), void *))
+%define_as(SWIG_as_voidptrptr(a), ((void)%as_voidptr(*a),%reinterpret_cast(a, void**)))
+}
+
+
+/* -----------------------------------------------------------------------------
+ * Allocating/freeing elements
+ * ----------------------------------------------------------------------------- */
+
+#if defined(__cplusplus)
+# define %new_instance(Type...)             (new Type())
+# define %new_copy(val,Type...)             (new Type(%static_cast(val, const Type&)))
+# define %new_array(size,Type...)           (new Type[size]())
+# define %new_copy_array(ptr,size,Type...)  %reinterpret_cast(memcpy(new Type[size], ptr, sizeof(Type)*(size)), Type*)
+# define %delete(cptr)                      delete cptr
+# define %delete_array(cptr)                delete[] cptr
+#else /* C case */
+# define %new_instance(Type...)             (Type *)calloc(1,sizeof(Type))
+# define %new_copy(val,Type...)             (Type *)memcpy(%new_instance(Type),&val,sizeof(Type))
+# define %new_array(size,Type...)           (Type *)calloc(size, sizeof(Type))
+# define %new_copy_array(ptr,size,Type...)  (Type *)memcpy(malloc((size)*sizeof(Type)), ptr, sizeof(Type)*(size))
+# define %delete(cptr)                      free((char*)cptr)
+# define %delete_array(cptr)                free((char*)cptr)
+#endif /* __cplusplus */
+
+/* -----------------------------------------------------------------------------
+ * SWIG names and mangling
+ * ----------------------------------------------------------------------------- */
+
+#define %mangle(Type...)                  #@Type
+#define %descriptor(Type...)               SWIGTYPE_ ## #@Type
+#define %string_name(Name)                "SWIG_" %str(Name)
+#define %symbol_name(Name, Type...)       SWIG_ ## Name ## _ #@Type
+#define %checkcode(Code)           	  SWIG_TYPECHECK_ ## Code
+
+
+/* -----------------------------------------------------------------------------
+ * Auxiliary loop macros
+ * ----------------------------------------------------------------------------- */
+
+
+/* for loop for macro with one argument */
+%define %_formacro_1(macro, arg1,...)macro(arg1)
+#if #__VA_ARGS__ != "__fordone__"
+%_formacro_1(macro, __VA_ARGS__)
+#endif
+%enddef
+
+/* for loop for macro with one argument */
+%define %formacro_1(macro,...)%_formacro_1(macro,__VA_ARGS__,__fordone__)%enddef
+%define %formacro(macro,...)%_formacro_1(macro,__VA_ARGS__,__fordone__)%enddef
+
+/* for loop for macro with two arguments */
+%define %_formacro_2(macro, arg1, arg2, ...)macro(arg1, arg2)
+#if #__VA_ARGS__ != "__fordone__"
+%_formacro_2(macro, __VA_ARGS__)
+#endif
+%enddef
+
+/* for loop for macro with two arguments */
+%define %formacro_2(macro,...)%_formacro_2(macro, __VA_ARGS__, __fordone__)%enddef
+
+/* -----------------------------------------------------------------------------
+ * SWIG flags
+ * ----------------------------------------------------------------------------- */
+
+/*
+  mark a flag, ie, define a macro name but ignore it in
+  the interface.
+
+  the flag can be later used with %evalif
+*/
+
+%define %mark_flag(x) %define x 1 %enddef %enddef
+
+
+/*
+  %evalif and %evalif_2 are use to evaluate or process
+  an expression if the given predicate is 'true' (1).
+*/
+%define %_evalif(_x,_expr)
+#if _x == 1
+_expr
+#endif
+%enddef
+
+%define %_evalif_2(_x,_y,_expr)
+#if _x == 1 && _y == 1
+_expr
+#endif
+%enddef
+
+%define %evalif(_x,_expr...) %_evalif(%arg(_x),%arg(_expr)) %enddef
+
+%define %evalif_2(_x,_y,_expr...) %_evalif_2(%arg(_x),%arg(_y),%arg(_expr)) %enddef
+
diff --git a/share/swig/2.0.11/typemaps/swigobject.swg b/share/swig/3.0.12/typemaps/swigobject.swg
index b1e6dc9..b1e6dc9 100644
--- a/share/swig/2.0.11/typemaps/swigobject.swg
+++ b/share/swig/3.0.12/typemaps/swigobject.swg
diff --git a/share/swig/3.0.12/typemaps/swigtype.swg b/share/swig/3.0.12/typemaps/swigtype.swg
new file mode 100644
index 0000000..d3633eb
--- /dev/null
+++ b/share/swig/3.0.12/typemaps/swigtype.swg
@@ -0,0 +1,699 @@
+/* -----------------------------------------------------------------------------
+ * --- Input arguments --- 
+ * ----------------------------------------------------------------------------- */
+/* Pointers and arrays */
+%typemap(in, noblock=1) SWIGTYPE *(void  *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp,$descriptor, $disown | %convertptr_flags);
+  if (!SWIG_IsOK(res)) { 
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  $1 = %reinterpret_cast(argp, $ltype);
+}
+%typemap(freearg) SWIGTYPE * "";
+
+%typemap(in, noblock=1) SWIGTYPE [] (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp,$descriptor, $disown | %convertptr_flags);
+  if (!SWIG_IsOK(res)) { 
+    %argument_fail(res, "$type", $symname, $argnum); 
+  } 
+  $1 = %reinterpret_cast(argp, $ltype);
+}
+%typemap(freearg) SWIGTYPE [] "";
+
+
+%typemap(in, noblock=1) SWIGTYPE *const&  (void *argp = 0, int res = 0, $*1_ltype temp) {
+  res = SWIG_ConvertPtr($input, &argp, $*descriptor, $disown | %convertptr_flags);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$*ltype", $symname, $argnum); 
+  }
+  temp = %reinterpret_cast(argp, $*ltype);
+  $1 = %reinterpret_cast(&temp, $1_ltype);
+}
+%typemap(freearg) SWIGTYPE *const& "";
+
+
+/* Reference */
+%typemap(in, noblock=1) SWIGTYPE & (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp, $descriptor, %convertptr_flags);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (!argp) { %argument_nullref("$type", $symname, $argnum); }
+  $1 = %reinterpret_cast(argp, $ltype);
+}
+%typemap(freearg) SWIGTYPE & "";
+
+#if defined(__cplusplus) && defined(%implicitconv_flag)
+%typemap(in,noblock=1,implicitconv=1) const SWIGTYPE & (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp, $descriptor, %convertptr_flags | %implicitconv_flag);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (!argp) { %argument_nullref("$type", $symname, $argnum); }
+  $1 = %reinterpret_cast(argp, $ltype);
+}
+%typemap(freearg,noblock=1,match="in",implicitconv=1) const SWIGTYPE &
+{
+  if (SWIG_IsNewObj(res$argnum)) %delete($1);
+}
+#else
+%typemap(in,noblock=1) const SWIGTYPE & (void *argp, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp, $descriptor, %convertptr_flags);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (!argp) { %argument_nullref("$type", $symname, $argnum); }
+  $1 = %reinterpret_cast(argp, $ltype);
+}
+#endif
+
+/* Rvalue reference */
+%typemap(in, noblock=1) SWIGTYPE && (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp, $descriptor, %convertptr_flags);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (!argp) { %argument_nullref("$type", $symname, $argnum); }
+  $1 = %reinterpret_cast(argp, $ltype);
+}
+%typemap(freearg) SWIGTYPE && "";
+
+#if defined(__cplusplus) && defined(%implicitconv_flag)
+%typemap(in,noblock=1,implicitconv=1) const SWIGTYPE && (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp, $descriptor, %convertptr_flags | %implicitconv_flag);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (!argp) { %argument_nullref("$type", $symname, $argnum); }
+  $1 = %reinterpret_cast(argp, $ltype);
+}
+%typemap(freearg,noblock=1,match="in",implicitconv=1) const SWIGTYPE &&
+{
+  if (SWIG_IsNewObj(res$argnum)) %delete($1);
+}
+#else
+%typemap(in,noblock=1) const SWIGTYPE && (void *argp, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp, $descriptor, %convertptr_flags);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }
+  if (!argp) { %argument_nullref("$type", $symname, $argnum); }
+  $1 = %reinterpret_cast(argp, $ltype);
+}
+#endif
+
+/* By value */
+#if defined(__cplusplus) && defined(%implicitconv_flag)
+%typemap(in,implicitconv=1) SWIGTYPE (void *argp, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp, $&descriptor, %convertptr_flags | %implicitconv_flag);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }  
+  if (!argp) { 
+    %argument_nullref("$type", $symname, $argnum);
+  } else {
+    $&ltype temp = %reinterpret_cast(argp, $&ltype);
+    $1 = *temp;
+    if (SWIG_IsNewObj(res)) %delete(temp);
+  }
+}
+#else
+%typemap(in) SWIGTYPE (void *argp, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp, $&descriptor, %convertptr_flags);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res, "$type", $symname, $argnum); 
+  }  
+  if (!argp) { 
+    %argument_nullref("$type", $symname, $argnum);
+  } else {
+    $1 = *(%reinterpret_cast(argp, $&ltype));
+  }
+}
+#endif
+
+
+/* -----------------------------------------------------------------------------
+ * --- Output arguments --- 
+ * ----------------------------------------------------------------------------- */
+
+/* Pointers, references */
+%typemap(out,noblock=1) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE[] {
+  %set_output(SWIG_NewPointerObj(%as_voidptr($1), $descriptor, $owner | %newpointer_flags));
+}
+
+%typemap(out, noblock=1) SWIGTYPE *const& {
+  %set_output(SWIG_NewPointerObj(%as_voidptr(*$1), $*descriptor, $owner | %newpointer_flags));
+}
+
+/* Return by value */
+%typemap(out, noblock=1) SWIGTYPE {
+  %set_output(SWIG_NewPointerObj(%new_copy($1, $ltype), $&descriptor, SWIG_POINTER_OWN | %newpointer_flags));
+}
+
+/* -----------------------------------------------------------------------------
+ * --- Variable input --- 
+ * ----------------------------------------------------------------------------- */
+
+/* memberin/globalin/varin, for fix arrays. */
+
+%typemap(memberin) SWIGTYPE [ANY] {
+  if ($input) {
+    size_t ii = 0;
+    for (; ii < (size_t)$1_dim0; ++ii) *($1_basetype *)&$1[ii] = *(($1_basetype *)$input + ii);
+  } else {
+    %variable_nullref("$type","$name");
+  }
+}
+
+%typemap(globalin) SWIGTYPE [ANY] {
+  if ($input) {
+    size_t ii = 0;
+    for (; ii < (size_t)$1_dim0; ++ii) *($1_basetype *)&$1[ii] = *(($1_basetype *)$input + ii);
+  } else {
+    %variable_nullref("$type","$name");
+  }
+}
+
+%typemap(varin) SWIGTYPE [ANY] {
+  $basetype *inp = 0;
+  int res = SWIG_ConvertPtr($input, %as_voidptrptr(&inp), $descriptor, %convertptr_flags);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  } else if (inp) {
+    size_t ii = 0;
+    for (; ii < (size_t)$1_dim0; ++ii) *($1_basetype *)&$1[ii] = *(($1_basetype *)inp + ii);
+  } else {
+    %variable_nullref("$type", "$name");
+  }
+}
+
+
+/* memberin/globalin/varin, for fix double arrays. */
+
+%typemap(memberin) SWIGTYPE [ANY][ANY] {
+  if ($input) {
+    size_t ii = 0;
+    for (; ii < (size_t)$1_dim0; ++ii) {
+      if ($input[ii]) {
+	size_t jj = 0;
+	for (; jj < (size_t)$1_dim1; ++jj) $1[ii][jj] = $input[ii][jj];
+      } else {
+	%variable_nullref("$type","$name");
+      }
+    }
+  } else {
+    %variable_nullref("$type","$name");
+  }
+}
+
+%typemap(globalin) SWIGTYPE [ANY][ANY] {
+  if ($input) {
+    size_t ii = 0;
+    for (; ii < (size_t)$1_dim0; ++ii) {
+      if ($input[ii]) {
+	size_t jj = 0;
+	for (; jj < (size_t)$1_dim1; ++jj) $1[ii][jj] = $input[ii][jj];
+      } else {
+	%variable_nullref("$type","$name");
+      }
+    }
+  } else {
+    %variable_nullref("$type","$name");
+  }
+}
+
+%typemap(varin) SWIGTYPE [ANY][ANY] {
+  $basetype (*inp)[$1_dim1] = 0;
+  int res = SWIG_ConvertPtr($input, %as_voidptrptr(&inp), $descriptor, %convertptr_flags);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  } else if (inp) {
+    size_t ii = 0;
+    for (; ii < (size_t)$1_dim0; ++ii) {
+      if (inp[ii]) {
+	size_t jj = 0;
+	for (; jj < (size_t)$1_dim1; ++jj) $1[ii][jj] = inp[ii][jj];
+      } else {
+	%variable_nullref("$type", "$name");
+      }
+    }
+  } else {
+    %variable_nullref("$type", "$name");
+  }
+}
+
+/* Pointers, references, and variable size arrays */
+
+%typemap(varin,warning=SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG) SWIGTYPE * {
+  void *argp = 0;
+  int res = SWIG_ConvertPtr($input, &argp, $descriptor, %convertptr_flags);  
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  $1 = %reinterpret_cast(argp, $ltype);
+}
+
+%typemap(varin,noblock=1,warning="462:Unable to set dimensionless array variable") SWIGTYPE []
+{
+  %variable_fail(SWIG_AttributeError, "$type", "read-only $name");
+}
+
+%typemap(varin,warning=SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG) SWIGTYPE & {
+  void *argp = 0;
+  int res = SWIG_ConvertPtr($input, &argp, $descriptor, %convertptr_flags);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  if (!argp) {
+    %variable_nullref("$type", "$name");
+  }
+  $1 = *(%reinterpret_cast(argp, $ltype));
+}
+
+%typemap(varin,warning=SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG) SWIGTYPE && {
+  void *argp = 0;
+  int res = SWIG_ConvertPtr($input, &argp, $descriptor, %convertptr_flags);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  if (!argp) {
+    %variable_nullref("$type", "$name");
+  }
+  $1 = *(%reinterpret_cast(argp, $ltype));
+}
+
+#if defined(__cplusplus) && defined(%implicitconv_flag)
+%typemap(varin,implicitconv=1) SWIGTYPE {
+  void *argp = 0;
+  int res = SWIG_ConvertPtr($input, &argp, $&descriptor, %convertptr_flags | %implicitconv_flag);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  if (!argp) {
+    %variable_nullref("$type", "$name");
+  } else {
+    $&type temp;
+    temp  = %reinterpret_cast(argp, $&type);
+    $1 = *temp;
+    if (SWIG_IsNewObj(res)) %delete(temp);
+  }
+}
+#else
+%typemap(varin) SWIGTYPE {
+  void *argp = 0;
+  int res = SWIG_ConvertPtr($input, &argp, $&descriptor, %convertptr_flags);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  if (!argp) {
+    %variable_nullref("$type", "$name");
+  } else {
+    $1 = *(%reinterpret_cast(argp, $&type));
+  }
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * --- Variable output --- 
+ * ----------------------------------------------------------------------------- */
+
+/* Pointers and arrays */
+%typemap(varout, noblock=1) SWIGTYPE * {
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr($1), $descriptor, %newpointer_flags));
+}
+
+%typemap(varout, noblock=1) SWIGTYPE [] {
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr($1), $descriptor, %newpointer_flags));
+}
+
+/* References */
+%typemap(varout, noblock=1) SWIGTYPE & {
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(&$1), $descriptor, %newpointer_flags));
+}
+
+%typemap(varout, noblock=1) SWIGTYPE && {
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(&$1), $descriptor, %newpointer_flags));
+}
+
+/* Value */
+%typemap(varout, noblock=1) SWIGTYPE {
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(&$1), $&descriptor, %newpointer_flags));
+}
+
+/* ------------------------------------------------------------
+ * --- Typechecking rules ---
+ * ------------------------------------------------------------ */
+
+%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1) SWIGTYPE * {
+  void *vptr = 0;
+  int res = SWIG_ConvertPtr($input, &vptr, $descriptor, 0);
+  $1 = SWIG_CheckState(res);
+}
+
+%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1) SWIGTYPE *const& {
+  void *vptr = 0;
+  int res = SWIG_ConvertPtr($input, &vptr, $*descriptor, 0);
+  $1 = SWIG_CheckState(res);
+}
+
+%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1) SWIGTYPE & {
+  void *vptr = 0;
+  int res = SWIG_ConvertPtr($input, &vptr, $descriptor, 0);
+  $1 = SWIG_CheckState(res);
+}
+
+%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1) SWIGTYPE && {
+  void *vptr = 0;
+  int res = SWIG_ConvertPtr($input, &vptr, $descriptor, 0);
+  $1 = SWIG_CheckState(res);
+}
+
+#if defined(__cplusplus) && defined(%implicitconv_flag)
+%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1,implicitconv=1) const SWIGTYPE & {
+  int res = SWIG_ConvertPtr($input, 0, $descriptor, %implicitconv_flag);
+  $1 = SWIG_CheckState(res);
+}
+
+%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1,implicitconv=1) const SWIGTYPE && {
+  int res = SWIG_ConvertPtr($input, 0, $descriptor, %implicitconv_flag);
+  $1 = SWIG_CheckState(res);
+}
+
+%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1,implicitconv=1) SWIGTYPE {
+  int res = SWIG_ConvertPtr($input, 0, $&descriptor, %implicitconv_flag);
+  $1 = SWIG_CheckState(res);
+}
+#else
+%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1) const SWIGTYPE & {
+  void *vptr = 0;
+  int res = SWIG_ConvertPtr($input, &vptr, $descriptor, 0);
+  $1 = SWIG_CheckState(res);
+}
+%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1) const SWIGTYPE && {
+  void *vptr = 0;
+  int res = SWIG_ConvertPtr($input, &vptr, $descriptor, 0);
+  $1 = SWIG_CheckState(res);
+}
+
+%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1) SWIGTYPE {
+  void *vptr = 0;
+  int res = SWIG_ConvertPtr($input, &vptr, $&descriptor, 0);
+  $1 = SWIG_CheckState(res);
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * --- Director typemaps --- *  
+ * ----------------------------------------------------------------------------- */
+
+#if defined(SWIG_DIRECTOR_TYPEMAPS)
+
+/* directorin */
+
+%typemap(directorin,noblock=1) SWIGTYPE *, SWIGTYPE *const& {
+  $input = SWIG_NewPointerObj(%as_voidptr($1), $descriptor, %newpointer_flags);
+}
+
+%typemap(directorin,noblock=1) SWIGTYPE {
+  $input = SWIG_NewPointerObj(%as_voidptr(new $1_ltype((const $1_ltype &)$1)), $&descriptor, SWIG_POINTER_OWN | %newpointer_flags);
+}
+
+%typemap(directorin,noblock=1) SWIGTYPE & {
+  $input = SWIG_NewPointerObj(%as_voidptr(&$1), $descriptor, %newpointer_flags);
+}
+
+%typemap(directorin,noblock=1) SWIGTYPE && {
+  $input = SWIG_NewPointerObj(%as_voidptr(&$1_name), $descriptor, %newpointer_flags);
+}
+
+/* directorout */
+#if defined(__cplusplus) && defined(%implicitconv_flag)
+%typemap(directorout,noblock=1,implicitconv=1) SWIGTYPE (void * swig_argp, int swig_res = 0) {
+  swig_res = SWIG_ConvertPtr($input,&swig_argp,$&descriptor, %convertptr_flags | %implicitconv_flag);
+  if (!SWIG_IsOK(swig_res)) {
+    %dirout_fail(swig_res,"$type");
+  }
+  $result = *(%reinterpret_cast(swig_argp, $&ltype));
+  if (SWIG_IsNewObj(swig_res)) %delete(%reinterpret_cast(swig_argp, $&ltype));
+}
+#else
+%typemap(directorout,noblock=1) SWIGTYPE (void * swig_argp, int swig_res = 0) {
+  swig_res = SWIG_ConvertPtr($input,&swig_argp,$&descriptor, %convertptr_flags);
+  if (!SWIG_IsOK(swig_res)) {
+    %dirout_fail(swig_res,"$type");
+  }
+  $result = *(%reinterpret_cast(swig_argp, $&ltype));
+}
+#endif
+
+%typemap(directorout,noblock=1,warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) 
+  SWIGTYPE *(void *swig_argp, int swig_res, swig_owntype own) {
+  swig_res = SWIG_ConvertPtrAndOwn($input, &swig_argp, $descriptor, %convertptr_flags | SWIG_POINTER_DISOWN, &own);
+  if (!SWIG_IsOK(swig_res)) {
+    %dirout_fail(swig_res,"$type");
+  }
+  $result = %reinterpret_cast(swig_argp, $ltype);
+  swig_acquire_ownership_obj(%as_voidptr($result), own /* & TODO: SWIG_POINTER_OWN */);
+}
+%typemap(directorfree,noblock=1,match="directorout") SWIGTYPE * {
+  if (director) {
+    SWIG_AcquirePtr($result, director->swig_release_ownership(%as_voidptr($input)));
+  }
+}
+
+%typemap(directorout,noblock=1,warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) 
+  SWIGTYPE &(void *swig_argp, int swig_res, swig_owntype own) {
+  swig_res = SWIG_ConvertPtrAndOwn($input, &swig_argp, $descriptor, %convertptr_flags | SWIG_POINTER_DISOWN, &own);
+  if (!SWIG_IsOK(swig_res)) {
+    %dirout_fail(swig_res,"$type");
+  }
+  if (!swig_argp) { %dirout_nullref("$type"); }
+  $result = %reinterpret_cast(swig_argp, $ltype);
+  swig_acquire_ownership_obj(%as_voidptr($result), own /* & TODO: SWIG_POINTER_OWN */);
+}
+%typemap(directorfree,noblock=1,match="directorout") SWIGTYPE & {
+  if (director) {
+    SWIG_AcquirePtr($result, director->swig_release_ownership(%as_voidptr($input)));
+  }
+}
+
+%typemap(directorout,noblock=1,warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) 
+  SWIGTYPE &&(void *swig_argp, int swig_res, swig_owntype own) {
+  swig_res = SWIG_ConvertPtrAndOwn($input, &swig_argp, $descriptor, %convertptr_flags | SWIG_POINTER_DISOWN, &own);
+  if (!SWIG_IsOK(swig_res)) {
+    %dirout_fail(swig_res,"$type");
+  }
+  if (!swig_argp) { %dirout_nullref("$type"); }
+  $result = %reinterpret_cast(swig_argp, $ltype);
+  swig_acquire_ownership_obj(%as_voidptr($result), own /* & TODO: SWIG_POINTER_OWN */);
+}
+%typemap(directorfree,noblock=1,match="directorout") SWIGTYPE && {
+  if (director) {
+    SWIG_AcquirePtr($result, director->swig_release_ownership(%as_voidptr($input)));
+  }
+}
+
+#endif /* SWIG_DIRECTOR_TYPEMAPS */
+
+
+/* ------------------------------------------------------------
+ * --- Constants ---
+ * ------------------------------------------------------------ */
+
+%typemap(constcode,noblock=1) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] {
+  %set_constant("$symname", SWIG_NewPointerObj(%as_voidptr($value),$descriptor,%newpointer_flags));
+}
+
+%typemap(constcode,noblock=1) SWIGTYPE {
+  %set_constant("$symname", SWIG_NewPointerObj(%as_voidptr(&$value),$&descriptor,%newpointer_flags));
+}
+
+/* ------------------------------------------------------------
+ * --- Exception handling ---
+ * ------------------------------------------------------------ */
+
+%typemap(throws,noblock=1) SWIGTYPE {
+  %raise(SWIG_NewPointerObj(%new_copy($1, $ltype),$&descriptor,SWIG_POINTER_OWN), "$type", $&descriptor);
+}
+
+%typemap(throws,noblock=1) SWIGTYPE * {
+  %raise(SWIG_NewPointerObj(%as_voidptr($1),$descriptor,0), "$type", $descriptor);
+}
+
+%typemap(throws,noblock=1) SWIGTYPE [ANY] {
+  %raise(SWIG_NewPointerObj(%as_voidptr($1),$descriptor,0), "$type", $descriptor);
+}
+
+%typemap(throws,noblock=1) SWIGTYPE & {
+  %raise(SWIG_NewPointerObj(%as_voidptr(&$1),$descriptor,0), "$type", $descriptor);
+}
+
+%typemap(throws,noblock=1) SWIGTYPE && {
+  %raise(SWIG_NewPointerObj(%as_voidptr(&$1),$descriptor,0), "$type", $descriptor);
+}
+
+%typemap(throws,noblock=1) (...) {
+  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
+}
+
+/* ------------------------------------------------------------
+ * --- CLASS::* typemaps --- 
+ * ------------------------------------------------------------ */
+
+%typemap(in) SWIGTYPE (CLASS::*) {  
+  int res = SWIG_ConvertMember($input, %as_voidptr(&$1), sizeof($type),$descriptor);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res,"$type",$symname, $argnum); 
+  }
+}
+
+%typemap(out,noblock=1) SWIGTYPE (CLASS::*) {
+  %set_output(SWIG_NewMemberObj(%as_voidptr(&$1), sizeof($type), $descriptor));
+}
+
+%typemap(varin) SWIGTYPE (CLASS::*) {
+  int res = SWIG_ConvertMember($input,%as_voidptr(&$1), sizeof($type), $descriptor);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name"); 
+  }
+}
+
+%typemap(varout,noblock=1) SWIGTYPE (CLASS::*) {
+  %set_varoutput(SWIG_NewMemberObj(%as_voidptr(&$1), sizeof($type), $descriptor));
+}
+
+%typemap(constcode,noblock=1) SWIGTYPE (CLASS::*) {
+  %set_constant("$symname", SWIG_NewMemberObj(%as_voidptr(&$value), sizeof($type), $descriptor));
+}
+
+#if defined(SWIG_DIRECTOR_TYPEMAPS)
+
+/* directorin */
+
+%typemap(directorin,noblock=1) SWIGTYPE (CLASS::*) {
+  $input = SWIG_NewMemberObj(%as_voidptr(&$1), sizeof($type), $descriptor);
+}
+
+/* directorout */
+
+%typemap(directorout) SWIGTYPE (CLASS::*) {
+  int swig_res = SWIG_ConvertMember($input,%as_voidptr(&$result), sizeof($type), $descriptor);
+  if (!SWIG_IsOK(swig_res)) {
+    %dirout_fail(swig_res,"$type");
+  }
+}
+#endif
+
+/* ------------------------------------------------------------
+ * --- function ptr typemaps --- 
+ * ------------------------------------------------------------ */
+
+/*
+  ISO C++ doesn't allow direct casting of a function ptr to a object
+  ptr. So, maybe the ptr sizes are not the same, and we need to take
+  some providences.
+ */
+%typemap(in) SWIGTYPE ((*)(ANY)) {
+  int res = SWIG_ConvertFunctionPtr($input, (void**)(&$1), $descriptor);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res,"$type",$symname, $argnum); 
+  }
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER,noblock=1) SWIGTYPE ((*)(ANY)) {
+  void *ptr = 0;
+  int res = SWIG_ConvertFunctionPtr($input, &ptr, $descriptor);
+  $1 = SWIG_CheckState(res);
+}
+
+
+%typemap(out, noblock=1) SWIGTYPE ((*)(ANY)) {
+  %set_output(SWIG_NewFunctionPtrObj((void *)($1), $descriptor));
+}
+
+%typemap(varin) SWIGTYPE ((*)(ANY)) {
+  int res = SWIG_ConvertFunctionPtr($input, (void**)(&$1), $descriptor);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name"); 
+  }
+}
+
+%typemap(varout,noblock=1) SWIGTYPE ((*)(ANY)) {  
+  %set_varoutput(SWIG_NewFunctionPtrObj((void *)($1), $descriptor));
+}
+
+%typemap(constcode, noblock=1) SWIGTYPE ((*)(ANY)){
+  %set_constant("$symname", SWIG_NewFunctionPtrObj((void *)$value, $descriptor));
+}
+%typemap(constcode) SWIGTYPE ((* const)(ANY)) = SWIGTYPE ((*)(ANY));
+
+#if defined(SWIG_DIRECTOR_TYPEMAPS)
+
+/* directorin */
+
+%typemap(directorin,noblock=1) SWIGTYPE ((*)(ANY)) {
+  $input = SWIG_NewFunctionPtrObj((void*)($1), $descriptor);
+}
+
+/* directorout */
+
+%typemap(directorout) SWIGTYPE ((*)(ANY)) {
+  int swig_res = SWIG_ConvertFunctionPtr($input,(void**)(&$result),$descriptor);
+  if (!SWIG_IsOK(swig_res)) {
+    %dirout_fail(swig_res,"$type");
+  }
+}
+#endif
+
+%apply SWIGTYPE * { SWIGTYPE *const }
+
+/* ------------------------------------------------------------
+ * --- Special typemaps ---
+ * ------------------------------------------------------------ */
+
+/* DISOWN typemap */
+
+%typemap(in, noblock=1) SWIGTYPE *DISOWN (int res = 0) {
+  res = SWIG_ConvertPtr($input, %as_voidptrptr(&$1), $descriptor, SWIG_POINTER_DISOWN | %convertptr_flags);
+  if (!SWIG_IsOK(res)) {
+    %argument_fail(res,"$type", $symname, $argnum);
+  }
+}
+
+%typemap(varin) SWIGTYPE *DISOWN {
+  void *temp = 0;
+  int res = SWIG_ConvertPtr($input, &temp, $descriptor, SWIG_POINTER_DISOWN | %convertptr_flags);
+  if (!SWIG_IsOK(res)) {
+    %variable_fail(res, "$type", "$name");
+  }
+  $1 = ($ltype) temp;
+}
+
+/* DYNAMIC typemap */
+
+%typemap(out,noblock=1) SWIGTYPE *DYNAMIC, SWIGTYPE &DYNAMIC {
+  %set_output(SWIG_NewPointerObj(%as_voidptr($1), SWIG_TypeDynamicCast($descriptor, %as_voidptrptr(&$1)), $owner | %newpointer_flags));
+}
+
+/* INSTANCE typemap */
+
+%typemap(out,noblock=1) SWIGTYPE INSTANCE {
+  %set_output(SWIG_NewInstanceObj(%new_copy($1, $1_ltype), $&1_descriptor, SWIG_POINTER_OWN | %newinstance_flags));
+}
+
+%typemap(out,noblock=1) SWIGTYPE *INSTANCE, SWIGTYPE &INSTANCE, SWIGTYPE INSTANCE[] {
+  %set_output(SWIG_NewInstanceObj(%as_voidptr($1), $1_descriptor, $owner | %newinstance_flags));
+}
+
+%typemap(varout,noblock=1) SWIGTYPE *INSTANCE, SWIGTYPE INSTANCE[] {
+  %set_varoutput(SWIG_NewInstanceObj(%as_voidptr($1), $1_descriptor, %newinstance_flags));
+}
+
+%typemap(varout,noblock=1) SWIGTYPE &INSTANCE {
+  %set_varoutput(SWIG_NewInstanceObj(%as_voidptr($1), $1_descriptor, %newinstance_flags));
+}
+
+%typemap(varout,noblock=1) SWIGTYPE INSTANCE {
+  %set_varoutput(SWIG_NewInstanceObj(%as_voidptr(&$1), $&1_descriptor, %newinstance_flags));
+}
+
diff --git a/share/swig/3.0.12/typemaps/swigtypemaps.swg b/share/swig/3.0.12/typemaps/swigtypemaps.swg
new file mode 100644
index 0000000..4e5bb2b
--- /dev/null
+++ b/share/swig/3.0.12/typemaps/swigtypemaps.swg
@@ -0,0 +1,167 @@
+/* -----------------------------------------------------------------------------
+ * swigtypemaps.swg
+ *
+ * Unified Typemap Library frontend
+ * ----------------------------------------------------------------------------- */
+
+/*
+  This file provides the frontend to the Unified Typemap Library.
+
+  When using this library in a SWIG target language, you need to
+  define a minimum set of fragments, specialize a couple of macros,
+  and then include this file.
+
+  Typically you will create a 'mytypemaps.swg' file in each target
+  language, where you will have the following sections:
+
+    === mytypemaps.swg ===
+
+    //  Fragment section 
+    %include <typemaps/fragments.swg>
+    <include target language fragments>
+
+    // Unified typemap section 
+    <specialized the typemap library macros>
+    %include <typemaps/swigtypemaps.swg>
+
+    // Local typemap section 
+    <add/replace extra target language typemaps>
+
+    === mytypemaps.swg ===
+
+  While we add more docs, please take a look at the following cases
+  to see how you specialized the unified typemap library for a new
+  target language:
+
+      Lib/python/pytypemaps.swg
+      Lib/tcl/tcltypemaps.swg
+      Lib/ruby/rubytypemaps.swg
+      Lib/perl5/perltypemaps.swg
+    
+*/
+
+#define SWIGUTL SWIGUTL
+
+/* -----------------------------------------------------------------------------
+ *   Language specialization section. 
+ *
+ *   Tune these macros for each language as needed.
+ * ----------------------------------------------------------------------------- */
+
+/*
+  The SWIG target language object must be provided.
+  For example in python you define:
+
+    #define SWIG_Object PyObject *
+*/
+
+#if !defined(SWIG_Object) 
+#error "SWIG_Object must be defined as the SWIG target language object"
+#endif
+
+/*==== flags for new/convert methods ====*/
+
+
+#ifndef %convertptr_flags
+%define %convertptr_flags  0 %enddef
+#endif
+
+#ifndef %newpointer_flags
+%define %newpointer_flags  0 %enddef
+#endif
+
+#ifndef %newinstance_flags
+%define %newinstance_flags 0 %enddef
+#endif
+
+/*==== set output ====*/
+
+#ifndef %set_output
+/* simple set output operation */
+#define %set_output(obj)                  $result = obj
+#endif
+
+/*==== set variable output  ====*/
+
+#ifndef %set_varoutput
+/* simple set varoutput operation */
+#define %set_varoutput(obj)               $result = obj
+#endif
+
+/*==== append output ====*/
+
+#ifndef %append_output
+#if defined(SWIG_AppendOutput)
+/* simple append operation */
+#define %append_output(obj)               $result = SWIG_AppendOutput($result,obj) 
+#else
+#error "Language must define SWIG_AppendOutput or %append_output"
+#endif
+#endif
+
+/*==== set constant ====*/
+
+#ifndef %set_constant
+#if defined(SWIG_SetConstant)
+/* simple set constant operation */
+#define %set_constant(name,value)         SWIG_SetConstant(name,value)
+#else
+#error "Language must define SWIG_SetConstant or %set_constant"
+#endif
+#endif
+
+/*==== raise an exception ====*/
+
+#ifndef %raise
+#if defined(SWIG_Raise)
+/* simple raise operation */
+#define %raise(obj, type, desc)           SWIG_Raise(obj, type, desc); SWIG_fail
+#else
+#error "Language must define SWIG_Raise or %raise"
+#endif
+#endif
+
+/*==== director output exception ====*/
+
+#if defined(SWIG_DIRECTOR_TYPEMAPS)
+#ifndef SWIG_DirOutFail
+#define SWIG_DirOutFail(code, msg)        Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(code), msg)
+#endif
+#endif
+
+
+/* -----------------------------------------------------------------------------
+ *  Language independent definitions
+ * ----------------------------------------------------------------------------- */
+
+#define %error_block(Block...)                 %block(Block)
+#define %default_code(code)                    SWIG_ArgError(code)  
+#define %argument_fail(code, type, name, argn) SWIG_exception_fail(%default_code(code), %argfail_fmt(type, name, argn))
+#define %argument_nullref(type, name, argn)    SWIG_exception_fail(SWIG_ValueError, %argnullref_fmt(type, name, argn))
+#define %variable_fail(code, type, name)       SWIG_exception_fail(%default_code(code), %varfail_fmt(type, name))
+#define %variable_nullref(type, name)          SWIG_exception_fail(SWIG_ValueError, %varnullref_fmt(type, name))
+
+#if defined(SWIG_DIRECTOR_TYPEMAPS)
+#define %dirout_fail(code, type)          SWIG_DirOutFail(%default_code(code), %outfail_fmt(type))
+#define %dirout_nullref(type)             SWIG_DirOutFail(SWIG_ValueError, %outnullref_fmt(type))
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  All the typemaps
+ * ----------------------------------------------------------------------------- */
+
+
+%include <typemaps/fragments.swg>
+%include <typemaps/exception.swg>
+%include <typemaps/swigtype.swg>
+%include <typemaps/void.swg>
+%include <typemaps/swigobject.swg>
+%include <typemaps/valtypes.swg>
+%include <typemaps/ptrtypes.swg>
+%include <typemaps/inoutlist.swg>
+%include <typemaps/primtypes.swg>
+%include <typemaps/string.swg>
+%include <typemaps/misctypes.swg>
+%include <typemaps/enumint.swg>
+
+
diff --git a/share/swig/2.0.11/typemaps/typemaps.swg b/share/swig/3.0.12/typemaps/typemaps.swg
index 4629e8d..4629e8d 100644
--- a/share/swig/2.0.11/typemaps/typemaps.swg
+++ b/share/swig/3.0.12/typemaps/typemaps.swg
diff --git a/share/swig/2.0.11/typemaps/valtypes.swg b/share/swig/3.0.12/typemaps/valtypes.swg
index 11eac59..11eac59 100644
--- a/share/swig/2.0.11/typemaps/valtypes.swg
+++ b/share/swig/3.0.12/typemaps/valtypes.swg
diff --git a/share/swig/2.0.11/typemaps/void.swg b/share/swig/3.0.12/typemaps/void.swg
index bbd68ed..bbd68ed 100644
--- a/share/swig/2.0.11/typemaps/void.swg
+++ b/share/swig/3.0.12/typemaps/void.swg
diff --git a/share/swig/3.0.12/typemaps/wstring.swg b/share/swig/3.0.12/typemaps/wstring.swg
new file mode 100644
index 0000000..cd409d1
--- /dev/null
+++ b/share/swig/3.0.12/typemaps/wstring.swg
@@ -0,0 +1,37 @@
+%ensure_fragment(SWIG_AsWCharPtrAndSize)
+%ensure_fragment(SWIG_FromWCharPtrAndSize)
+
+
+%types(wchar_t *);
+
+%fragment("SWIG_pwchar_descriptor","header") {
+SWIGINTERN swig_type_info*
+SWIG_pwchar_descriptor()
+{
+  static int init = 0;
+  static swig_type_info* info = 0;
+  if (!init) {
+    info = SWIG_TypeQuery("_p_wchar_t");
+    init = 1;
+  }
+  return info;
+}
+}
+
+%fragment("SWIG_wcsnlen","header",fragment="SWIG_FromWCharPtrAndSize") {
+SWIGINTERN size_t
+SWIG_wcsnlen(const wchar_t* s, size_t maxlen)
+{
+  const wchar_t *p;
+  for (p = s; maxlen-- && *p; p++)
+    ;
+  return p - s;
+}
+}
+
+%include <typemaps/strings.swg>
+%typemaps_string(%checkcode(UNISTRING), %checkcode(UNICHAR),
+		 wchar_t, WChar, SWIG_AsWCharPtrAndSize, SWIG_FromWCharPtrAndSize,
+		 wcslen, SWIG_wcsnlen,
+		"<wchar.h>", WCHAR_MIN, WCHAR_MAX)
+
diff --git a/share/swig/2.0.11/uffi/uffi.swg b/share/swig/3.0.12/uffi/uffi.swg
index 41b0859..41b0859 100644
--- a/share/swig/2.0.11/uffi/uffi.swg
+++ b/share/swig/3.0.12/uffi/uffi.swg
diff --git a/share/swig/2.0.11/wchar.i b/share/swig/3.0.12/wchar.i
index 14de346..14de346 100644
--- a/share/swig/2.0.11/wchar.i
+++ b/share/swig/3.0.12/wchar.i
diff --git a/share/swig/2.0.11/windows.i b/share/swig/3.0.12/windows.i
index 2c093da..2c093da 100644
--- a/share/swig/2.0.11/windows.i
+++ b/share/swig/3.0.12/windows.i